Nmeros aleatorios e histogramas

In [16]: from IPython.display import Image, SVG

Image('http://docs.scipy.org/doc/numpy/_static/scipyshiny_small.png')

Out[16]:

Python cuenta con un paquete para manejar nmeros aleatorios: random. Numpy tambin provee un
mdulo para lo mismo: numpy.random. En un mdulo de python este mdulo se puede importar de la
siguiente manera:
In [2]: import numpy.random as random
En las libretas de IPython tenemos este mdulo importado automaticamente, as que podemos omitir la
lnea anterior, y se puede utilizar el nombre random directamente. An ms, las funciones del mdulo
numpy.random estn importadas tambin.
Este mdulo contiene muchas funciones, como lo indica la documentacin del mismo. La primera
funcin que utilizaremos es rand. La funcin rand acepta mltiples argumentos de tipo entero y
devuelve un array con nmeros aleatorios distribuidos uniformemente en el intervalo [0, 1). El n-simo
argumento especifica cuantos elementos tendr el resultado en la n-sima dimensin. Por ejemplo, sin
argumentos la funcin devuelve un nmero real, no un array.
In [5]: rand()
Out[5]:

0.2948522668509709

Cuando se le pasa un solo argumento la funcin devuelve un array de una dimensin con tantos
elementos como el valor del argumento:
In [7]: array1 = rand(100)
array1
Out[7]:

array([ 0.86042958,

0.11982877,

0.90459994,

0.50012867,

0.23939382,

Out[7]:

array([ 0.86042958,
0.85945377,
0.89959196,
0.31222439,
0.3532621 ,
0.71587761,
0.98245212,
0.73118265,
0.85098181,
0.18134769,
0.60900508,
0.02506954,
0.92631893,
0.60203571,
0.21501653,
0.35890109,
0.17700521,
0.17291773,
0.94626691,
0.71146845,

0.11982877,
0.0843099 ,
0.85464747,
0.31422114,
0.01481433,
0.63283413,
0.57204995,
0.19807596,
0.74610299,
0.21464423,
0.71113451,
0.66386163,
0.97312886,
0.07179184,
0.1041074 ,
0.55831732,
0.04307611,
0.5515602 ,
0.64247289,
0.7888544 ,

0.90459994,
0.57102048,
0.49795208,
0.55160364,
0.06899619,
0.72027448,
0.20157833,
0.89376438,
0.25176204,
0.5736978 ,
0.20816306,
0.56114062,
0.75442341,
0.79012743,
0.53234235,
0.70125529,
0.43726711,
0.29189377,
0.91375992,
0.7576026 ,

0.50012867,
0.10681829,
0.75175593,
0.38605549,
0.7101838 ,
0.92460927,
0.8482856 ,
0.28910125,
0.70168444,
0.79254113,
0.49484541,
0.89493943,
0.02104746,
0.9862937 ,
0.85162438,
0.43579019,
0.73471963,
0.90826881,
0.80956887,
0.90819529,

0.23939382,
0.79911695,
0.28389981,
0.3969374 ,
0.25847932,
0.2076804 ,
0.13276008,
0.29094218,
0.13187107,
0.98795487,
0.07759344,
0.46278306,
0.13756306,
0.88497381,
0.66712256,
0.88388255,
0.58262215,
0.59926054,
0.65929853,
0.89439354])

In [21]: print array1.shape

(100L,)
Con dos argumentos la funcin general un array de dos dimensiones:
In [9]: array2 = rand(3, 3)
array2
Out[9]:

array([[ 0.85938113,
[ 0.6310969 ,
[ 0.12645231,

0.18180842,
0.12703708,
0.92144645,

0.71750739],
0.0714772 ],
0.37694204]])

In [25]: print array2.shape

(3L, 3L)
Ms argumentos generan un array de dimensin mayor. La funcin rand es una forma conveniente de
usar la funcin random_sample, la cual acepta un slo argumento, que es una tupla con el nmero de
elementos en cada dimensin:
In [37]: forma = (5, 5)
array2p = random_sample(forma)
array2p
Out[37]:

array([[ 0.12949035,
0.76276095],
[ 0.29488447,
],
[ 0.46079285,
0.92320943],

0.15303723,

0.79356053,

0.82453895,

0.28280531,

0.8526758 ,

0.32841885,

0.86997954,

0.93415309,

0.97265455,

0.2617546

[ 0.48957987,
0.42801597],
[ 0.92828127,
0.60298699]])

0.81257691,

0.81242181,

0.96195095,

0.90145906,

0.63353512,

0.4371138 ,

In [38]: print array2p.shape

(5L, 5L)
Otra funcin que genera nmeros, slo que esta vez son enteros aleatorios, es randint. Esta funcin
requiere de mnimo un argumento n, de tipo entero, tal que produce como resultado un entero en el
intervalo [0, n).
In [32]: randint(100)
Out[32]:

76

Adems la funcin acepta dos argumentos nombrados. El primero de ellos es high, que debe ser un
entero m, y cuando se especifica el resultado estar contenido en el intervalo [n, m) :
In [14]: randint(130, high=132)
Out[14]:

131

El tercer argumento es size, este argumento es una tupla de nmeros enteros que define la forma del
resultado, es decir, las dimensiones del array resultado y cuandos elementos tendr en cada
dimensin:
In [17]: forma4 = (10,8)
array4 = randint(130, high=140, size=forma4)
array4
Out[17]:

array([[132,
[135,
[131,
[133,
[132,
[137,
[136,
[136,
[134,
[130,

139,
133,
132,
135,
135,
136,
139,
139,
139,
130,

132,
138,
135,
132,
133,
131,
130,
131,
132,
134,

136,
132,
130,
136,
138,
132,
131,
135,
137,
131,

138,
136,
130,
133,
131,
135,
132,
132,
133,
134,

135,
134,
131,
130,
135,
133,
134,
138,
131,
138,

139,
131,
137,
130,
139,
133,
131,
130,
134,
130,

139],
135],
131],
135],
134],
133],
131],
136],
134],
132]])

Similar a randint es la funcin random_integers, la cual acepta los mismos argumentos que
randint, slo que en el caso en que slo se especifica el primer argumento n devuelve un entero en el
intervalo [1, n].
In [40]: random_integers(2, size=(10))
Out[40]:

array([2, 2, 1, 1, 2, 2, 1, 2, 2, 2])

Out[40]:

array([2, 2, 1, 1, 2, 2, 1, 2, 2, 2])

Si se especific el argumento nombrado high su comportamiento es igual a randint.

In [41]: random_integers(2, high=5, size=(10))
Out[41]:

array([5, 5, 3, 3, 5, 3, 4, 2, 5, 2])

Ejemplo. Simulando el lanzamiento de dos dados.

Consideremos que tenemos dos dados, los cuales lanzamos diez mil veces. Queremos graficar la
distribucin de la suma de los valores de cada uno de los lanzamientos, es decir, cuantas veces se
repite un valor determinado.
Cuando lanzamos un dado el valor que resulta es completamente aleatorio, pero siempre es un valor
entero entre 1 y 6 . El primer lanzamiento tendra un valor V 1 aleatorio, el segundo un valor V 2 , y as
sucesivamente hasta el diezmilsimo lanzamiento V 1000 . Es claro que podramos crear una lista con los
valores de todos los lanzamientos, y lo mismo podramos hacer para el segundo dado. Podemos hacer
esto con la funcin random_integers de la siguiente forma:
In [21]: repeticiones = 100000
dado1 = random_integers(1, high=6, size=repeticiones)
dado2 = random_integers(1, high=6, size=repeticiones)
Las variables dado1 y dado2 son arrays de diez mil elementos. Veamos, por ejemplo, los primeros cien
elementos de dado1:
In [44]: dado1[:100]
Out[44]:

array([6,
3,
1,
6,
3,
4,
5,
2,
2,

3, 2, 2, 2, 5, 3, 4, 6, 6, 3, 6, 6, 2, 3, 2, 4, 6, 3, 5, 5, 6,
4, 6, 2, 6, 5, 5, 4, 4, 6, 6, 5, 1, 3, 1, 3, 3, 6, 4, 3, 4, 1,
1, 6, 2, 6, 4, 4, 5, 5, 1, 1, 3, 5, 5, 6, 5, 2, 2, 3, 4, 5, 4,
3, 1, 6, 3, 4, 4, 3, 1, 2, 1, 2, 5, 1, 4, 6, 4, 5, 5, 2, 3, 6,
6, 1, 1, 2, 6, 5, 1])

Ahora bien, cual ser la distribucin de los valores de los lanzamientos del primer dado? Si el dado no
est cargado entonces no hay razn para que un valor predomine sobre los otros, es decir, que la
probabilidad de que salga cualquier valor entre uno y seis es la misma.
Como visualizamos esta distribucin? Matplotlib cuenta con una funcin para visualizar la distribucin
de una serie de datos: hist.

La funcin hist
hist es una funcin que sirve para graficar un histograma. Un histograma es una representacin
grfica de una variable, en forma de barras, donde el rea de la barra es proporcional a la frecuencia
con que un valor particular de la variable se repite.
Para usar la funcin hist basta con pasarle un argumento que contenga los datos a graficar. La
frecuencia con que aparece cada dato es determinado por la misma funcin de manera automtica. As,
para graficar la distribucin de los valores del lanzamiento del primer dado ejecutamos
In [22]: SIZE = (6, 6)
rc('font', size=14)
fig1 = figure(figsize=SIZE)
title(u'Distribucin de los lanzamientos del primer dado')
xlabel(u'Valor del lanzamiento')
ylabel(u'Frecuencia')
hist(dado1)

Out[22]:

(array([ 16491.,
0., 16480.,
0., 16862., 16610.]),
array([ 1. , 1.5, 2. , 2.5, 3. ,
]),
<a list of 10 Patch objects>)

0.,
3.5,

16706.,
4. ,

4.5,

0.,
5. ,

16851.,
5.5,

6.

La grfica nos muestra que la frecuencia de cada lanzamiento es prcticamente la misma, salvo
pequeas variaciones. La frecuencia de cada valor est cerca del valor promedio para cada
lanzamiento:
In [23]: 100000/6
Out[23]:

16666

Qu sucede cuando tenemos dos dados lanzados simultneamente? En este caso se suman los
valores de ambos dado, por lo que los valores de los lanzamientos estarn dados por
In [25]: total = dado1 + dado2
y su distribucin es
In [26]: SIZE = (6, 6)
rc('font', size=14)
fig1 = figure(figsize=SIZE)
title(u'Distribucin de los lanzamientos de dos dados')
xlabel(u'Valor del lanzamiento')
ylabel(u'Frecuencia')
hist(total, bins=11)

Out[26]:

(array([

2740.,
5609.,
8161., 11053., 13914., 16812., 13960.,
11062.,
8508.,
5509.,
2672.]),
array([ 2.
,
2.90909091,
3.81818182,
4.72727273,
5.63636364,
6.54545455,
7.45454545,
8.36363636,
9.27272727, 10.18181818, 11.09090909, 12.
]),
<a list of 11 Patch objects>)

La distribucin del lanzamiento de dos dados es muy diferente. En este caso el valor que ms se
presenta es 7, y los valores 1 y 12 son los menos comunes. Esta distrbucin tan particular se conoce
como distrubucin normal, o distribucin gaussiana.
In [6]: Image(url='http://upload.wikimedia.org/wikipedia/commons/thumb/3/3a/Stand

Out[6]:

El histograma de los dados solo se extiende sobre el intervalo de 2 a 12, pero presenta un
comportamiento bastante similar al de la distribucin normal.
La funcin hist puede mostrar la frecuencia relativa en el eje y , es decir, la proporcion de los eventos
respecto al total. Esto se logra usando el argumento nombrado normed, el cual debe tener el valor True
para lograr este efecto:
In [14]: SIZE = (8, 8)
rc('font', size=14)
fig1 = figure(figsize=SIZE)
title(u'Distribucin de los lanzamientos de dos dados')
xlabel(u'Valor del lanzamiento')
ylabel(u'Frecuencia')
hist(total, bins=11, color='red', normed=True)

Out[14]:

(array([ 0.03036, 0.06105, 0.09251, 0.12254, 0.15532, 0.18447,

0.14817, 0.11924, 0.09482, 0.06303, 0.02849]),
array([ 2.
,
2.90909091,
3.81818182,
4.72727273,
5.63636364,
6.54545455,
7.45454545,
8.36363636,

5.63636364,
6.54545455,
9.27272727, 10.18181818,
<a list of 11 Patch objects>)

7.45454545,
11.09090909,

Ejercicios

Ejercicio 1
Grafique la distribucin del lanzamiento de tres, cuatro, cinco y seis dados.
In [ ]:

8.36363636,
12.
]),