Sesión 3
Introducción a Stata II
Juan D. Baró[email protected]
Métodos Cuantitativos en Economía Regional y Urbana
Universidad Autónoma de Occidente
27 de abril de 2011
Versión : 1.2
Copyright © 2011: La reproducción total o parcial de este material está prohibida
Material provisional y sujeto a cambios
1. Trabajando con datos
Cuando se usa el comando “use archivo”, Stata (i) verifica si el archivo
está en el directorio, (ii) pregunta si tiene permiso para leerlo y
(iii) copia el archivo completo a la memoria (si es posible)
___ ____ ____ ____ ____ tm
/__ / ____/ / ____/
___/ / /___/ / /___/ 10.1 Copyright 1984-2009
Statistics/Data Analysis StataCorp
4905 Lakeway Drive
Special Edition College Station, Texas 77845 USA
800-STATA-PC http://www.stata.com
979-696-4600 [email protected]
979-696-4601 (fax)
Single-user Stata for Windows perpetual license:
Serial number: 81910049383
Licensed to: BANCO DE LA REPUBLICA
BANCO DE LA REPUBLICA
Notes:
1. (/m# option or -set memory-) 10.00 MB allocated to data
2. (/v# option or -set maxvar-) 5000 maximum variables
Por defecto, Stata solo lee bases de datos de 10 megas o menos
Si la base de datos es más grande use el comando:
. set memory 910m
El comando compress reduce el tamaño de la base de datos que se está usando: . compress
3
1.1 Los datos en la memoria
Una vez se carga una base de datos en formato Stata (comando use)
podemos ver el contenido de ésta con el comando describe
. use auto, clear
(1978 Automobile Data)
. describe
Contains data from C:\Archivos de programa\Stata10\ado\base/a/auto.dta
obs: 74 1978 Automobile Data
vars: 12 13 Apr 2007 17:45
size: 3,478 (99.7% of memory free) (_dta has notes)
--------------------------------------------------------------------------------------
storage display value
variable name type format label variable label
--------------------------------------------------------------------------------------
make str18 %-18s Make and Model
price int %8.0gc Price
mpg int %8.0g Mileage (mpg)
rep78 int %8.0g Repair Record 1978
headroom float %6.1f Headroom (in.)
trunk int %8.0g Trunk space (cu. ft.)
weight int %8.0gc Weight (lbs.)
length int %8.0g Length (in.)
turn int %8.0g Turn Circle (ft.)
displacement int %8.0g Displacement (cu. in.)
gear_ratio float %6.2f Gear Ratio
foreign byte %8.0g origin Car type
---------------------------------------------------------------------------------------
Sorted by: foreign 4
if exp y in range non tienen sentido en la sintaxis del comando describe.
Pero las listas de variables si:
. describe price
storage display value
variable name type format label variable label
--------------------------------------------------------------------
price int %8.0gc Price
. describe price displacement
storage display value
variable name type format label variable label
--------------------------------------------------------------------
price int %8.0gc Price
displacement int %8.0g Displacement (cu. in.)
5
. describe m*
storage display value
variable name type format label variable label
-----------------------------------------------------------------
make str18 %-18s Make and Model
mpg int %8.0g Mileage (mpg)
. describe mpg-trunk
storage display value
variable name type format label variable label
-----------------------------------------------------------------
mpg int %8.0g Mileage (mpg)
rep78 int %8.0g Repair Record 1978
headroom float %6.1f Headroom (in.)
trunk int %8.0g Trunk space (cu. ft.)
6
Una de las mejores formas de obtener descripciones de las variables es a
través del comando codebook
. describe make
storage display value
variable name type format label variable label
-------------------------------------------------------------------------
make str18 %-18s Make and Model
. codebook make
-------------------------------------------------------------------------
make Make and Model
-------------------------------------------------------------------------
type: string (str18), but longest is str17
unique values: 74 missing "": 0/74
examples: "Cad. Deville"
"Dodge Magnum"
"Merc. XR-7"
"Pont. Catalina"
warning: variable has embedded blanks
7
Codebook para una variable numérica
. codebook mpg
----------------------------------------------------------------------------------
mpg Mileage (mpg)
----------------------------------------------------------------------------------
type: numeric (int)
range: [12,41] units: 1
unique values: 21 missing .: 0/74
mean: 21.2973
std. dev: 5.7855
percentiles: 10% 25% 50% 75% 90%
14 18 20 25 29
8
Tipos de variables
De texto (strings)
Numéricas (numeric)
Tipo de
datos
Tipo de
variableSignificado
De texto
(string)
str1 Texto de máximo 1 caracter
str2 Texto de máximo 2 caracteres
strn Texto de máximo n caracteres
str244 Texto de máximo 244 caracteres
Numérica
byte Entero entre -127 y 100
int Entero entre -32.767 y 32.740
long Entero entre -2,147,483,647 y 2,147,483,620
float Real con aprox. 8 digitos de precisión
double Real con aprox. 17 digitos de precisión
9
Use el comando describe para ver el tipo de variable
Contains data from C:\Archivos de programa\Stata10\ado\base/a/auto.dta
obs: 74 1978 Automobile Data
vars: 12 13 Apr 2007 17:45
size: 3,478 (99.9% of memory free) (_dta has notes)
------------------------------------------------------------------------------
storage display value
variable name type format label variable label
------------------------------------------------------------------------------
make str18 %-18s Make and Model
price int %8.0gc Price
mpg int %8.0g Mileage (mpg)
rep78 int %8.0g Repair Record 1978
headroom float %6.1f Headroom (in.)
trunk int %8.0g Trunk space (cu. ft.)
weight int %8.0gc Weight (lbs.)
length int %8.0g Length (in.)
turn int %8.0g Turn Circle (ft.)
displacement int %8.0g Displacement (cu. in.)
gear_ratio float %6.2f Gear Ratio
foreign byte %8.0g origin Car type
------------------------------------------------------------------------------
Sorted by: foreign
Note: dataset has changed since last saved
10
Variable Categórica
• Contienen valores como 1, 2 , 3 …. Cada valor tiene un significado
• Cualquier conjunto de números serviría
• En la representación no necesariamente se tienen que usar números
• Una variable de texto que contiene “hombre” o “mujer” es una
variable categórica
• La variable make en la base de datos auto.dta es una variable
categórica (ver 2 diapositivas atrás)
• Sin embargo, es muchísimo mejor si las variables categóricas están
codificadas numéricamente
11
Ejemplo de variable categórica codificada numéricamente:
• codebook muestra tabulación y no estadísticas descriptivas
(Stata se da cuenta que la variable toma pocos valores)
• codedebook realmente no sabe que esta es una variable
categórica
. codebook rep78
-------------------------------------------------------------------------
rep78 Repair Record 1978
-------------------------------------------------------------------------
type: numeric (int)
range: [1,5] units: 1
unique values: 5 missing .: 5/74
tabulation: Freq. Value
2 1
8 2
30 3
18 4
11 5
5 .
12
Variable categórica codificada numéricamente (con value labels):
• La variable foreign toma valores 1 y 0. Toma 0 si es “doméstico” 1
si es “importado” (y Stata lo sabe)
• codebook y describe lucen diferentes para esta variable
(label: origin)
. codebook foreign
-------------------------------------------------------------------------
foreign Car type
-------------------------------------------------------------------------
type: numeric (byte)
label: origin
range: [0,1] units: 1
unique values: 2 missing .: 0/74
tabulation: Freq. Numeric Label
52 0 Domestic
22 1 Foreign
. describe gear_ratio foreign
storage display value
variable name type format label variable label
-------------------------------------------------------------------------
gear_ratio float %6.2f Gear Ratio
foreign byte %8.0g origin Car type
13
1.2 Value labels (etiquetas de valores)
• Importantes para organizar información fácilmente
• Asignación de número a texto
• En el caso de la variable foreign, el value label “origin” es una nota
que le dice a Stata:
• Cuando vea 0; no muestre “0”; muestre “Domestic”
• Cuando vea 1; no muestre “1”; muestre “Foreign”
• Cuando listamos algunas observaciones no vemos 0 o 1, sino vemos
“Domestic” o “Foreign”:
. sort foreign make
. list make mpg foreign in 1/5
+--------------------------------+
| make mpg foreign |
|--------------------------------|
1. | AMC Concord 22 Domestic |
2. | AMC Pacer 17 Domestic |
3. | AMC Spirit 22 Domestic |
4. | Buick Century 20 Domestic |
5. | Buick Electra 15 Domestic |
+--------------------------------+
14
• Para crear una etiqueta de valores se siguen dos pasos sencillos:
1. Crear la asignación (llamado el value label):
. label define origin 0 "Domestic" 1 "Foreign"
2. Asociar el value label con la variable:
. label values foreign origin
• Crear y asignar el value label a una variable, no cambia el hecho de
que la variable sigue siendo numérica
. summarize foreign
Variable | Obs Mean Std. Dev. Min Max
-------------+-----------------------------------------------------
foreign | 74 .2972973 .4601885 0 1
15
• La variable es numérica, pero cuando se pueden usar los value labels
se usarán (recuerde cuando listamos la variable foreign).
• Cuando tabulamos la variable (comando tabulate) sucede algo similar:
. tabulate foreign
Car type | Freq. Percent Cum.
------------+-----------------------------------
Domestic | 52 70.27 70.27
Foreign | 22 29.73 100.00
------------+-----------------------------------
Total | 74 100.00
• Podemos decirle a Stata que esconda las etiquetas en tabulate y list:
. tabulate foreign, nolabel
Car type | Freq. Percent Cum.
------------+-----------------------------------
0 | 52 70.27 70.27
1 | 22 29.73 100.00
------------+-----------------------------------
Total | 74 100.00
16
Otros comandos relacionados (siguiendo el ejemplo de foreign):
• Borrar la asociación de una variable (no asignar nada):
. label values foreign
• Para ver los value labels y la asignación:
. label list origin
• Para listar las características de los carros “Foreign”, NO podemos
usar el texto de la asignación, debemos usar el número:
. sort foreign make
. list make mpg if foreign==1
17
1.3 Otros tipos de de etiquetas
Etiquetas de base de datos: . label data “1978 Automobile Data”
Etiquetas de variables: . label var make “Make and Model”
. describe
Contains data from C:\Archivos de programa\Stata10\ado\base/a/auto.dta
obs: 74 1978 Automobile Data
vars: 12 13 Apr 2007 17:45
size: 3,478 (99.9% of memory free) (_dta has notes)
----------------------------------------------------------------------------------storage display value
variable name type format label variable label
----------------------------------------------------------------------------------
make str18 %-18s Make and Model
price int %8.0gc Price
mpg int %8.0g Mileage (mpg)
rep78 int %8.0g Repair Record 1978
headroom float %6.1f Headroom (in.)
trunk int %8.0g Trunk space (cu. ft.)
weight int %8.0gc Weight (lbs.)
length int %8.0g Length (in.)
turn int %8.0g Turn Circle (ft.)
displacement int %8.0g Displacement (cu. in.)
gear_ratio float %6.2f Gear Ratio
foreign byte %8.0g origin Car type
----------------------------------------------------------------------------------
Sorted by: foreign
18
2. Reportes básicos de información
Los comandos recomendados para reportes básicos de datos son:
• describe (se introdujo atrás)
• codebook (se introdujo atrás)
• list
• browse (alternativa a list)
• count
• inspect (alternativa a codebook, preferible codebook)
• summarize (se introdujo atrás)
• table
• tabulate (se introdujo atrás)
20
Comando count
. count if exp in range
• Cuenta observaciones que cumplen con ciertas características
• ¡No permite variables!
• Ejemplos:
¿Cuántos carros domésticos hay en la base de datos?
. count if foreign == 1
52
¿Cuántos carros tienen un desempeño de más de 22 millas por
galón (mpg) y además son importados?
. count if mpg>22 & foreign == 1
15
21
La sintaxis de Stata es mucho más poderosa de lo que se ha mostrado.
Una versión más completa de la sintaxis de los comandos de Stata es:
. by variables: comando variables2 if exp in range
“by” en frente de un comando ejecuta el comando independientemente
para cada grupo
“by” tiene una restricción y es que la variable debe estar ordenada. Por
ello en muchos casos es mejor usar “bysort” en lugar de “by”
Ejemplo: ¿Cuántos carros rinden 20 millas o más por galón
discriminando por doméstico o importado?
. by foreign: count if mpg>=20
----------------------------------------------------------
-> foreign = Domestic
22
----------------------------------------------------------
-> foreign = Foreign
17
22
Lo mismo se podría lograr con el comando tabulate:
. tabulate foreign if mpg>=20
Car type | Freq. Percent Cum.
------------+-----------------------------------
Domestic | 22 56.41 56.41
Foreign | 17 43.59 100.00
------------+-----------------------------------
Total | 39 100.00
23
3. Manipulación de datos
Los comandos recomendados para manipulación de datos son:
(no los veremos todos a la vez, pero los veremos todos)
• generate y replace
• egen
• rename
• drop
• keep
• sort
• encode
• decode
• order
• reshape
• Nos detenemos en los siguientes en estas diapositivas:
• generate y replace (usados con by)
• egen
• encode
25
El comando “generate” permite crear variables nuevas y el comando
“replace” permite cambiar valores de las ya existentes
. generate nuevavar = exp
. replace nuevavar = exp
Ejemplos:
. generate lbperin = length/weight
. generate lbperin = weight/length
. generate nalcaro = 0
. replace nalcaro = 1 if foreign == 0 & price >= 6000
. replace nalcaro = 99 in 1/10
26
Se pueden combinar funciones en Stata con la generación de variables
(matemáticas o de texto):
. generate manuf = word(make, 1)
. codebook make manuf
La función word(n,s) toma como argumentos un texto y un entero
indicando cual palabra se quiere obtener
Para ver qué hace la función exactamente, use el comando display
(display es una forma fácil y rápida de ver resultados de prueba):
. display word("Este es un ejemplo", 4)
ejemplo
La función aplicada a una variable ejecuta lo que hace la función para
todas las obs de esa variable. Para ver más funciones en Stata:
. help functions
27
4. De variables de texto (strings)
a numéricas
• Stata maneja variables de texto y numéricas bastante bien
• En muchas ocasiones preferimos usar variables numéricas
(queremos usar comandos que generen estadísticas)
• Las variables de texto contienen uno de dos tipos de información
• Identificadores únicos para cada obs (ej. make)
• Categorías no únicas (ej. manuf)
• Si tiene un identificador déjelo como texto
• Si tiene categorías convierta esa variable en una variable numérica, y
aplique “value labels” para que se vea idéntica a la variable de texto
(ventaja: podemos usarlo en análisis estadísticos)
• Nota | Este tema es fundamental para el manejo y procesamiento de
encuestas. Se usa frecuentemente
29
¿Qué queremos hacer exactamente?
Tenemos una variable de texto (manuf) y queremos crear una variable
numérica con etiquetas de valores (value labels). Esa nueva variable la
llamamos manuf2
En general habrá varias observaciones que fueron manufacturados por la
misma empresa
manuf manuf2 value label
AMC 1 1 -> AMC
Audi 2 2 -> Audi
BMW 3 3 -> BMW
. . .
. . .
Volvo 23 23 -> Volvo
30
Existen al menos tres formas de hacerlo en Stata:
1. Usando el comando encode
. encode manuf, gen(manuf2)
2. Usando el comando egen combiando con la función group()
. egen manuf2: group(manuf), label
3. Manualmente, usando operaciones elementales en los datos
• Se mostrarán las tres formas pero empezaremos por la tercera
• Muchas veces se debe hacer algo similar ya que no existe el comando
que maneje todas las situaciones: ¡hay que saber como hacerlo!
31
Manualmente:
Primero, cargando la información y generando la variable manuf
(se había hecho en diapositivas anteriores)
. sysuse auto, clear
(1978 Automobile Data)
. generate manuf = word(make, 1)
. sort manuf
. l manuf in 1/8
+-------+
| manuf |
|-------|
1. | AMC |
2. | AMC |
3. | AMC |
4. | Audi |
5. | Audi |
|-------|
6. | BMW |
7. | Buick |
8. | Buick |
+-------+ 32
• La parte generate manuf2 = 1 if _n==1 crea una variable numérica
manuf2, igual a 1 o nada. Pondrá 1s en manuf2, donde _n==1, y nada
(“.”) en el resto
• _n: notación de la observación actual. _n es 1 para la primera obs,
_n es 2 para la segunda, _n es 3 para la tercera,….
• Dado que se usa by (se ejecuta el comando para cada grupo
independientemente), _n es 1 para la obs 4 también.
La obs 4 es la primera obs del grupo “Audi” (definido por manuf)
. by manuf: generate manuf2 = 1 if _n==1
(51 missing values generated)
. list manuf manuf2 in 1/8
+----------------+
| manuf manuf2 |
|----------------|
1. | AMC 1 |
2. | AMC . |
3. | AMC . |
4. | Audi 1 |
5. | Audi . |
6. | BMW 1 |
7. | Buick 1 |
8. | Buick . |
+----------------+ 33
Gráficamente
by manuf: generate manuf2 = 1 if _n==1 creó manuf2 conteniendo 1 en
la primera observación de cada grupo
Valor por
defecto de _n
Los datos by manuf:
_nmanuf manuf2
1 AMC 1 1
2 AMC . 2
3 AMC . 3
4 Audi 1 1
5 Audi . 2
6 BMW 1 1
7 Buick 1 1
8 Buick . 2
34
El último paso es usar la función sum()
sum(manuf2) : Produce la suma acumulada de la variable manuf2
(empezando por la primera obs) y tratando los “.” como 0
. replace manuf2 = sum(manuf2)
(73 real changes made)
. list manuf manuf2 in 1/8
+----------------+
| manuf manuf2 |
|----------------|
1. | AMC 1 |
2. | AMC 1 |
3. | AMC 1 |
4. | Audi 2 |
5. | Audi 2 |
6. | BMW 3 |
7. | Buick 4 |
8. | Buick 4 |
+----------------+
Se obtiene lo que se buscaba: 1 corresponde a AMC, 2 a Audi, 3 a BMW,
4 a Buick, ...
Hay formas más fáciles para este caso, pero se quería mostrar cómo
funciona Stata
manuf manuf2 sum(manuf2)
AMC 1 1
AMC . 1
AMC . 1
Audi 1 2
Audi . 2
BMW 1 3
Buick 1 4
Buick . 4
35
Una forma más fácil: Usando el comando egen(otras funciones del comando egen: . help egen)
. sysuse auto, clear(1978 Automobile Data)
. generate manuf = word(make, 1)
. egen manuf2=group(manuf), label
. tab manuf2
group(manuf |) | Freq. Percent Cum.
------------+-----------------------------------AMC | 3 4.05 4.05
Audi | 2 2.70 6.76BMW | 1 1.35 8.11
Buick | 7 9.46 17.57<Parte del output omitido>------------+-----------------------------------
Total | 74 100.00
. des manuf2
storage display value
variable name type format label variable label
----------------------------------------------------------------------
manuf2 float %9.0g manuf2 group(manuf)
36
Forma más eficiente: usando el comando encode
. sysuse auto, clear
(1978 Automobile Data)
. generate manuf = word(make, 1)
. encode manuf, gen(manuf2)
. codebook manuf2
---------------------------------------------------------------------------------
manuf2 (unlabeled)
---------------------------------------------------------------------------------
type: numeric (long)
label: manuf2
range: [1,23] units: 1
unique values: 23 missing .: 0/74
examples: 5 Cad.
8 Dodge
14 Merc.
18 Pont.
Para ver las etiquetas de valores, recuerde usar:. labelbook list manuf2
37
4. Subíndices de observación
_n y _N
• _n se introdujo en la recodificación de variables de texto a numéricas
• _n: Notación para el subdíndice de obs (número de obs actual)
• _N: Número total de observaciones (útil cuando se combina con by)
+-------------+
| familia edad|
|-------------|
1. | 2 3 |
2. | 0 5 |
3. | 3 0 |
4. | 0 2 |
5. | 0 6 |
|-------------|
6. | 2 1 |
7. | 1 6 |
8. | 0 1 |
9. | 1 4 |
10. | 2 0 |
+-------------+
Ejemplo:
• Suponga que analizamos el
comportamiento de hermanos
• Tenemos un identificador de familia
• Queremos una nueva variable que
contenga el número de hermanos para
cada individuo
39
Primero, ordenamos por familia (para que queden contiguos)
. sort familia
+--------------+
| familia edad |
|--------------|
1. | 0 1 |
2. | 0 2 |
3. | 0 5 |
4. | 0 6 |
5. | 1 4 |
|--------------|
6. | 1 6 |
7. | 2 0 |
8. | 2 1 |
9. | 2 3 |
10. | 3 0 |
+--------------+
+-------------+
| familia edad|
|-------------|
1. | 2 3 |
2. | 0 5 |
3. | 3 0 |
4. | 0 2 |
5. | 0 6 |
|-------------|
6. | 2 1 |
7. | 1 6 |
8. | 0 1 |
9. | 1 4 |
10. | 2 0 |
+-------------+
40
Ahora, creamos la nueva variable con by (porque es para cada familia)
. sort familia
. by familia: generate hrms = _N
+----------------------+
| familia edad hrms |
|----------------------|
1. | 0 1 4 |
2. | 0 2 4 |
3. | 0 5 4 |
4. | 0 6 4 |
5. | 1 4 2 |
|----------------------|
6. | 1 6 2 |
7. | 2 0 3 |
8. | 2 1 3 |
9. | 2 3 3 |
10. | 3 0 1 |
+----------------------+
41
Para generar el orden de nacimiento en cada familia, usaríamos
. sort familia edad
. by familia: generate orden = _N - _n +1
+------------------------------+
| familia edad hrms orden |
|------------------------------|
1. | 0 1 4 4 |
2. | 0 2 4 3 |
3. | 0 5 4 2 |
4. | 0 6 4 1 |
5. | 1 4 2 2 |
|------------------------------|
6. | 1 6 2 1 |
7. | 2 0 3 3 |
8. | 2 1 3 2 |
9. | 2 3 3 1 |
10. | 3 0 1 1 |
+------------------------------+
42
Resumen
De estas diapositivas usted debe tener un entendimiento general de cómo
Stata maneja la información. Ahora usted sabe que:
• Stata carga toda la base de datos en la memoria
• Etiquetas se pueden aplicar a los datos
• Los comandos de reporte (describe, codebook, list, etc.) revelan
información sobre la base de datos
• Los comando de manipulación de datos (generate, replace, egen, etc.)
ayudan a preparar los datos para el análisis
• De diversas formas, Stata permite crear variables numéricas
(categóricas) a partir de variables de texto
• Stata tiene subíndices explícitos (_n y _N)
43
Top Related