Matrices

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

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

Out[1]:

Las matrices son arreglos de elementos en dos dimensiones. Se representan como elementos en un
arreglo rectangular, el cual puede tener m filas y n columnas.

M 1,1

M 2,1
M =

M 1,1

M 1,2
M 2,2

M 1,2

M 1,n

M 2,n
,

M m,n

M n,m

Matrices en numpy
En numpy las matrices son un caso especial de los arreglos multidimensionales ndarray: las matrices
son arreglos de dos dimensiones, uno para las filas y otro para las columnas. Se necesitan dos ndices
para identificar un elemento de la matriz.

Creando matrices en numpy

Hay muchas formas de crear matrices en numpy.
Funcin ones

Esta funcin acepta un argumento que indica la forma que tendr el nuevo array, es decir, cuantas filas
y cuantas columnas tendr. El resultado que devuelve la funcin es una matriz de unos.
In [4]: forma1 = (10, 5)
# Diez filas por cinco columnas
matriz1 = ones(forma1)
# Se crea la matriz, y se guarda en una variabl
matriz1
# Muestra la matriz

Out[4]:

array([[
[
[
[
[
[
[
[
[
[

1.,
1.,
1.,
1.,
1.,
1.,
1.,
1.,
1.,
1.,

1.,
1.,
1.,
1.,
1.,
1.,
1.,
1.,
1.,
1.,

1.,
1.,
1.,
1.,
1.,
1.,
1.,
1.,
1.,
1.,

1.,
1.,
1.,
1.,
1.,
1.,
1.,
1.,
1.,
1.,

1.],
1.],
1.],
1.],
1.],
1.],
1.],
1.],
1.],
1.]])

Funcin zeros
Anloga a ones, pero el resultado es un arreglo de ceros.
In [5]: forma2 = (7, 8)
# Siete filas por ocho columnas
matriz2 = zeros(forma2)
matriz2
Out[5]:

array([[
[
[
[
[
[
[

0.,
0.,
0.,
0.,
0.,
0.,
0.,

0.,
0.,
0.,
0.,
0.,
0.,
0.,

0.,
0.,
0.,
0.,
0.,
0.,
0.,

0.,
0.,
0.,
0.,
0.,
0.,
0.,

0.,
0.,
0.,
0.,
0.,
0.,
0.,

0.,
0.,
0.,
0.,
0.,
0.,
0.,

0.,
0.,
0.,
0.,
0.,
0.,
0.,

0.],
0.],
0.],
0.],
0.],
0.],
0.]])

Funcin identity
Crea una matriz identidad, es decir, con unos en la diagonal principal y ceros en el resto de los
elementos. Acepta un argumento: el nmero de filas y de columnas de la matriz. La matriz identidad es
cuadrada, de n filas por n columnas.
In [7]: filas = 6
matriz_identidad = identity(filas)
matriz_identidad
Out[7]:

array([[
[
[
[

1.,
0.,
0.,
0.,

0.,
1.,
0.,
0.,

0.,
0.,
1.,
0.,

0.,
0.,
0.,
1.,

0.,
0.,
0.,
0.,

0.],
0.],
0.],
0.],

[ 0.,
[ 0.,

0.,
0.,

0.,
0.,

0.,
0.,

1.,
0.,

0.],
1.]])

Funcin diag
Crea una matriz cuadrada diagonal, es decir. Se le pasa un argmento, una lista que consiste de los
elementos de tendr la diagonal principal.
In [9]: elems_diagonal = [5, 8, -4, -16, 666, 56, 12, 99, -152, -11]
matriz_diagonal = diag(elems_diagonal)
matriz_diagonal

Out[9]:

array([[
[
[
[
[
[
[
[
[
[

5,
0,
0,
0,
0,
0,
0,
0,
0,
0,

0,
8,
0,
0,
0,
0,
0,
0,
0,
0,

0,
0,
-4,
0,
0,
0,
0,
0,
0,
0,

0,
0,
0,
-16,
0,
0,
0,
0,
0,
0,

0,
0,
0,
0,
666,
0,
0,
0,
0,
0,

0,
0,
0,
0,
0,
56,
0,
0,
0,
0,

0,
0,
0,
0,
0,
0,
12,
0,
0,
0,

0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
99,
0,
0, -152,
0,
0,

0],
0],
0],
0],
0],
0],
0],
0],
0],
-11]])

Funcin rand
Crea una matriz de nmeros aleatorios en el intervalo
el nmero de filas y el nmero de columnas.

[0, 1). Hay que pasarle dos argumentos enteros:

In [14]: filas, columnas = 10, 3

matriz_aleatoria = rand(filas, columnas)
matriz_aleatoria
Out[14]:

array([[
[
[
[
[
[
[
[
[
[

0.2002865 ,
0.77917584,
0.42901124,
0.68782721,
0.21001791,
0.13006853,
0.90199068,
0.05229118,
0.14453956,
0.75620908,

0.26887779,
0.43541702,
0.25557539,
0.94884664,
0.87353201,
0.76185967,
0.93931391,
0.82251621,
0.53457481,
0.00618516,

0.94346341],
0.64573693],
0.78001591],
0.86512828],
0.43399087],
0.37473635],
0.33328925],
0.77996395],
0.70662357],
0.39075013]])

Funcin randint
Devuelve un nmero aleatorios enteros. Esta funcin requiere de mnimo un argumento
entero, tal que el resultado es un entero en el intervalo [0, base).
In [22]: base = 155

# Lmite superior de los enteros aleatorios

base, de tipo

# Lmite superior de los enteros aleatorios

In [22]: base = 155
nrand = randint(base)
nrand

Out[22]:

111

Para crear una matriz hay que especificar, adems del primer argumento, el argumento nombrado size.
Este argumento es una tupla de nmeros enteros que define la forma del resultado, es decir, cuantas
filas y columnas tendr la matriz.
In [21]: base = 155
# Lmite superior de los enteros aleatorios
forma = (10, 5)
# Diez filas por 5 columnas
matriz_aleatoria_entera = randint(base, size=forma)
matriz_aleatoria_entera

Out[21]:

array([[102, 123, 35, 101, 63],

[ 12, 95, 102, 77, 27],
[104, 40, 148, 120, 132],
[ 99, 97, 72, 49, 77],
[ 36, 65, 106, 61, 141],
[ 59, 12, 46, 101, 46],
[106, 42, 102, 56, 10],
[130, 124, 48, 50, 17],
[102, 53, 64, 69, 46],
[ 59, 95, 17, 83, 52]])

Se puede especificar otro argumento nombrado, high, que debe ser un entero sup , y cuando se
especifica el resultado estar contenido en el intervalo [base, sup).
In [23]: base = 155
sup = 160

# Ahora base es el lmite inferior de los enteros aleatorio

# Lmite superior de los enteros aleatorios

forma = (10, 5)
# Diez filas por 5 columnas
matriz_aleatoria_entera = randint(base, high=sup, size=forma)
matriz_aleatoria_entera

Out[23]:

array([[157,
[159,
[156,
[159,
[156,
[156,
[157,
[156,
[156,
[159,

159,
158,
157,
158,
157,
158,
158,
159,
157,
156,

159,
159,
157,
156,
155,
157,
159,
159,
157,
156,

159,
159,
157,
156,
155,
159,
159,
155,
157,
155,

156],
158],
155],
159],
157],
157],
157],
159],
159],
155]])

Manipular matrices
Las matrices son arreglos de dos dimensiones, por lo tanto necesitamos especificar dos ndices para
identificar cada uno de sus elementos. La manera de hacerlo es igual a como se hace con arreglos de
una dimensin, con el operador de particin, los famosos corchetes []. La diferencia es que ahora
tendremos que especificar los dos ndices de un elemento en partcular, separandolos con comas.
Tomemos una matriz de nmeros aleatorios como base:
In [46]: filas, columnas = 11, 4
mat = rand(filas, columnas)
mat
Out[46]:

array([[
[
[
[
[
[
[
[
[
[
[

0.65453916,
0.51253953,
0.52326934,
0.50317073,
0.45898043,
0.26825337,
0.02640278,
0.68947099,
0.97442309,
0.16844096,
0.86604763,

0.01876896,
0.02039413,
0.30986745,
0.71370661,
0.67088425,
0.09546809,
0.40232014,
0.23741278,
0.95293486,
0.21269583,
0.38092307,

0.78148544,
0.06076788,
0.73484467,
0.47703042,
0.28352537,
0.86720485,
0.25040253,
0.91493267,
0.72084605,
0.23054219,
0.42106628,

0.84828785],
0.51177813],
0.44205504],
0.7454803 ],
0.15026625],
0.26511276],
0.07531441],
0.43774978],
0.3211908 ],
0.14232995],
0.06122231]])

Accediendo a las filas

Para acceder a las filas de una matriz usamos los corchetes con un solo ndice, que es el ndice de la
columa que queremos extraer.
En este ejemplo la variable mat es una matriz de 11 filas por 4 columnas. Recordemos que en python
los ndices empiezan en cero, no en uno, as que la primera fila tiene ndice 0. As, la primera fila de la
matriz mat es
In [47]: fila_indice = 0
fila = mat[fila_indice]
fila
Out[47]:

array([ 0.65453916,

0.01876896,

0.78148544,

0.84828785])

Efectivamente esto extrajo la primera fila. Si se cambia el valor de la variable fila_indice se pueden
extraer otras filas.
In [48]: fila_indice = 10
fila = mat[fila_indice]
fila

Out[48]:

array([ 0.86604763,

0.38092307,

0.42106628,

0.06122231])

Conclusin: para acceder a las filas especificamos un slo ndice dentro de los corchetes; el ndice
especifica la fila.

Accediendo a las columnas

Para acceder a las columnas de una matriz usamos los corchetes con dos ndices, slo que el primero
debe corresponde a los dos puntos, :, el segundo es el ndice de la columa que queremos extraer.
In [50]: columna_indice = 2
columna = mat[:, columna_indice]
columna

Out[50]:

array([ 0.78148544, 0.06076788,

0.86720485, 0.25040253,
0.42106628])

# El primer ndice son los dos puntos

0.73484467,
0.91493267,

0.47703042,
0.72084605,

0.28352537,
0.23054219,

Accediendo a elementos individuales

Para elementos individuales hay que especificar los dos ndices, el de la fila y el de la columna.
Recordemos que mat es
In [51]: mat
Out[51]:

array([[
[
[
[
[
[
[
[
[
[
[

0.65453916,
0.51253953,
0.52326934,
0.50317073,
0.45898043,
0.26825337,
0.02640278,
0.68947099,
0.97442309,
0.16844096,
0.86604763,

0.01876896,
0.02039413,
0.30986745,
0.71370661,
0.67088425,
0.09546809,
0.40232014,
0.23741278,
0.95293486,
0.21269583,
0.38092307,

0.78148544,
0.06076788,
0.73484467,
0.47703042,
0.28352537,
0.86720485,
0.25040253,
0.91493267,
0.72084605,
0.23054219,
0.42106628,

0.84828785],
0.51177813],
0.44205504],
0.7454803 ],
0.15026625],
0.26511276],
0.07531441],
0.43774978],
0.3211908 ],
0.14232995],
0.06122231]])

Por ejemplo, el elemento en la primera fila y la primera columna es

# La fila es m = 0, la columna es n = 0
In [52]: m, n = 0, 0
elem = mat[m, n]
# El elemento en la fila m y columna n de mat es
elem

Out[52]:

0.65453916449880156

Igualmente el elemento en la ltima fila y la ltima columna es

In [53]: m, n = -1, -1
elem = mat[m, n]

# La fila es m = -1 (ltima), la columna es n = -1 (lt

# El elemento en la fila m y columna n de mat es

elem

Out[53]:

0.061222309331296354

Se pueden especificar otros valores para las variables m y n y todo funciona de manera similar:
In [54]: m, n = 2, 3
# La fila es m = 2, la columna es n = 3
elem = mat[m, n]
# El elemento en la fila m y columna n de mat es
elem

Out[54]:

0.44205504398869055

Asignando un valor a un elemento de la matriz

Para reemplazar un elemento de la matriz se hace de la siguiente manera
# La fila es m = 0, la columna es n = 0
In [55]: m, n = 0, 0
mat[m, n] = 6.66666666
# Al elemento en la fila m y columna n de mat
mat

Out[55]:

array([[
[
[
[
[
[
[
[
[
[
[

6.66666666,
0.51253953,
0.52326934,
0.50317073,
0.45898043,
0.26825337,
0.02640278,
0.68947099,
0.97442309,
0.16844096,
0.86604763,

0.01876896,
0.02039413,
0.30986745,
0.71370661,
0.67088425,
0.09546809,
0.40232014,
0.23741278,
0.95293486,
0.21269583,
0.38092307,

0.78148544,
0.06076788,
0.73484467,
0.47703042,
0.28352537,
0.86720485,
0.25040253,
0.91493267,
0.72084605,
0.23054219,
0.42106628,

0.84828785],
0.51177813],
0.44205504],
0.7454803 ],
0.15026625],
0.26511276],
0.07531441],
0.43774978],
0.3211908 ],
0.14232995],
0.06122231]])

El elemento efectivamente ha sido reemplazado. Como hemos visto la asignacin se hace sobre la
variable mat especificando en los corchetes el ndice y la columna.

Iterando sobre los elementos de una matriz

Podemos usar la instruccin for .. in .. para iterar sobre los elementos de una matriz.

Iterar sobre las filas de una matriz

Para iterar sobre los elementos de una matriz usamos un for .. in .. sobre la matriz:
In [56]: filas, columnas = 11, 4
matriz = rand(filas, columnas)
matriz
Out[56]:

array([[
[
[
[
[
[
[
[
[
[
[

0.50209017,
0.94639172,
0.11321902,
0.14063406,
0.46996784,
0.64436161,
0.27997485,
0.97550061,
0.61081667,
0.8338188 ,
0.38523306,

0.93851252,
0.04594547,
0.60394931,
0.04681606,
0.80000167,
0.16414114,
0.61570686,
0.26363993,
0.22472446,
0.83422881,
0.15486907,

0.50351267,
0.97264301,
0.59491067,
0.79565573,
0.4721156 ,
0.44007561,
0.9446398 ,
0.9173331 ,
0.06097698,
0.36783317,
0.87512199,

0.81221498],
0.3890924 ],
0.27669201],
0.82699289],
0.26473768],
0.11066562],
0.9460158 ],
0.5468556 ],
0.88778227],
0.62228038],
0.43464254]])

In [66]: for fila in matriz:

print "Fila ->", fila
Fila
Fila
Fila
Fila
Fila
Fila
Fila
Fila
Fila
Fila
Fila

->
->
->
->
->
->
->
->
->
->
->

[
[
[
[
[
[
[
[
[
[
[

0.50209017
0.94639172
0.11321902
0.14063406
0.46996784
0.64436161
0.27997485
0.97550061
0.61081667
0.8338188
0.38523306

0.93851252
0.04594547
0.60394931
0.04681606
0.80000167
0.16414114
0.61570686
0.26363993
0.22472446
0.83422881
0.15486907

0.50351267
0.97264301
0.59491067
0.79565573
0.4721156
0.44007561
0.9446398
0.9173331
0.06097698
0.36783317
0.87512199

0.81221498]
0.3890924 ]
0.27669201]
0.82699289]
0.26473768]
0.11066562]
0.9460158 ]
0.5468556 ]
0.88778227]
0.62228038]
0.43464254]

Esto es as porque for .. in .. extrae los elementos identificados por el primer ndice de una matriz,
y el primer ndice especifica la fila.

Iterar sobre las filas con un ndice

El atributo shape de una matriz nos dice el nmero de filas y columas que tiene, es decir, la forma de la
matriz:
In [61]: forma = matriz.shape
forma
Out[61]:

(11L, 4L)

Por lo tanto podemos extraer las filas y columnas de esa forma:

In [62]: filas, columnas = forma
print 'La matriz tiene', filas, 'filas'
print 'La matriz tiene', columnas, 'columnas'
La matriz tiene 11 filas
La matriz tiene 4 columnas
Si creamos un contador que vaya desde cero hasta el nmero de filas menos uno (ndices son base
cero en python) podemos iterar sobre las filas especificando el ndice de las mismas. Para esto primero
creamos una lista con todos los ndices de las filas de la matriz.
In [67]: filas_indices = range(filas)

# La funcin range es buena manera de ge

filas_indices

Out[67]:

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Entonces ahora iteramos no sobre la matriz, sino sobre la lista de ndices. Luego usamos los ndices
para obtener la fila con dicho ndice:
In [68]: # Iteramos sobre los indices
for fila_indice in filas_indices:
fila = matriz[fila_indice]
print 'Fila ->', fila
Fila
Fila
Fila
Fila
Fila
Fila
Fila
Fila
Fila
Fila
Fila

->
->
->
->
->
->
->
->
->
->
->

[
[
[
[
[
[
[
[
[
[
[

0.50209017
0.94639172
0.11321902
0.14063406
0.46996784
0.64436161
0.27997485
0.97550061
0.61081667
0.8338188
0.38523306

0.93851252
0.04594547
0.60394931
0.04681606
0.80000167
0.16414114
0.61570686
0.26363993
0.22472446
0.83422881
0.15486907

0.50351267
0.97264301
0.59491067
0.79565573
0.4721156
0.44007561
0.9446398
0.9173331
0.06097698
0.36783317
0.87512199

0.81221498]
0.3890924 ]
0.27669201]
0.82699289]
0.26473768]
0.11066562]
0.9460158 ]
0.5468556 ]
0.88778227]
0.62228038]
0.43464254]

El resultado es idntico al obtenido al iterar sobre la matriz.

Iterando sobre las columnas con un ndice

Para acceder a las columnas de una matriz tenemos que iterar sobre los ndices de las columnas, y
luego extraer una columna con alguno de esos ndices.
Se procede de manera anloga a como se hizo con las filas. Creamos una lista con los ndices de las
columnas:
In [69]: columnas_indices = range(columnas)
columnas_indices
Out[69]:

[0, 1, 2, 3]

Ahora iteramos cobre la lista de ndices, y obtenemos la columna con dicho ndice.
In [70]: # Iteramos sobre los indices
for columna_indice in columnas_indices:
columna = matriz[:, columna_indice]
print 'Columna ->', columna
Columna -> [
0.64436161
0.27997485
Columna -> [
0.16414114
0.61570686
Columna -> [
0.44007561
0.9446398
Columna -> [
0.11066562
0.9460158

0.50209017

0.94639172

0.11321902

0.97550061 0.61081667 0.8338188

0.93851252 0.04594547 0.60394931

0.14063406

0.46996784

0.38523306]
0.04681606 0.80000167

0.26363993 0.22472446 0.83422881 0.15486907]

0.50351267 0.97264301 0.59491067 0.79565573 0.4721156
0.9173331
0.81221498
0.5468556

0.06097698 0.36783317 0.87512199]

0.3890924
0.27669201 0.82699289 0.26473768
0.88778227

0.62228038

0.43464254]

Para obtener la columna hemos usado dos puntos (:) para el primer ndice, y el segundo ndice indica la
columna a obtener.

Iterando sobre cada uno de los elementos

Para obtener cada uno de los elementos de la matriz se usa una mezcla de los procedimientos
anteriores, es decir, se itera sobre los ndices de las filas y de las columnas. Para lograr esto se usan
dos instrucciones for .. in .. anidadas. El primer for .. in .. sirve para iterar sobre el ndice de
las filas:

In [71]: for fila_indice in filas_indices:

# Iteracin sobre indices de las filas
pass
Cada iteracin sobre los indices de filas corresponde a una fila. Entonces, dentro de cada una de ellas
se realiza la iteracin sobre los ndices de las columnas, para acceder a la columna correspondiente.
In [72]: for fila_indice in filas_indices:
# Iteracin sobre indices de las filas
for columna_indice in columnas_indices:
# Iteramos sobre los indices de las columnas
pass
La dea del procedimento es simple:
Iterar sobre las filas, y luego, para cada fila, iterar sobre sus columnas.
Por brevedad reemplazemos las variables fila_indice y columna_indice por m y n respectivamente.
Entonces, dentro del for .. in .. ms interno obtenemos el valor del elemento de la matriz con
ndice m y columna n:
In [82]: for m in filas_indices:
# Iteracin sobre indices de las filas
print 'Elementos de la fila con indice', m
for n in columnas_indices:
# Iteramos sobre los indices de las columnas
elemento = matriz[m, n]
posicion = (m, n)
print '
Elemento en la posicin', posicion, 'es', elemento
print 'Pasando a otra fila...'
print
# Lnea en blanco
Elementos de la fila con indice
Elemento en la posicin (0,
Elemento en la posicin (0,
Elemento en la posicin (0,
Elemento en la posicin (0,
Pasando a otra fila...

0
0)
1)
2)
3)

es
es
es
es

0.502090172235
0.93851252227
0.503512668155
0.812214978111

Elementos de la fila con indice

Elemento en la posicin (1,
Elemento en la posicin (1,
Elemento en la posicin (1,
Elemento en la posicin (1,
Pasando a otra fila...

1
0)
1)
2)
3)

es
es
es
es

0.946391722895
0.0459454682317
0.972643013526
0.38909239563

Elementos de la fila con indice 2

Elemento en la posicin
Elemento en la posicin
Elemento en la posicin
Elemento en la posicin
Pasando a otra fila...

(2,
(2,
(2,
(2,

0)
1)
2)
3)

es
es
es
es

0.113219019769
0.603949306323
0.59491067283
0.276692012411

Elementos de la fila con indice

Elemento en la posicin (3,
Elemento en la posicin (3,
Elemento en la posicin (3,
Elemento en la posicin (3,
Pasando a otra fila...

3
0)
1)
2)
3)

es
es
es
es

0.140634055933
0.0468160589185
0.795655732977
0.826992888181

Elementos de la fila con indice

Elemento en la posicin (4,
Elemento en la posicin (4,
Elemento en la posicin (4,
Elemento en la posicin (4,
Pasando a otra fila...

4
0)
1)
2)
3)

es
es
es
es

0.469967837303
0.800001666198
0.472115602726
0.264737679007

Elementos de la fila con indice

Elemento en la posicin (5,
Elemento en la posicin (5,
Elemento en la posicin (5,
Elemento en la posicin (5,
Pasando a otra fila...

5
0)
1)
2)
3)

es
es
es
es

0.644361605365
0.164141136899
0.440075608379
0.110665618834

Elementos de la fila con indice

Elemento en la posicin (6,
Elemento en la posicin (6,
Elemento en la posicin (6,
Elemento en la posicin (6,
Pasando a otra fila...

6
0)
1)
2)
3)

es
es
es
es

0.279974853091
0.615706857967
0.944639802597
0.946015802446

Elementos de la fila con indice

Elemento en la posicin (7,
Elemento en la posicin (7,
Elemento en la posicin (7,
Elemento en la posicin (7,
Pasando a otra fila...

7
0)
1)
2)
3)

es
es
es
es

0.975500614187
0.263639932963
0.917333098006
0.546855598085

Elementos de la fila con indice

Elemento en la posicin (8,
Elemento en la posicin (8,
Elemento en la posicin (8,
Elemento en la posicin (8,
Pasando a otra fila...

8
0)
1)
2)
3)

es
es
es
es

0.610816672115
0.224724457262
0.0609769811169
0.887782270302

Elementos de
Elemento
Elemento
Elemento
Elemento

9
0)
1)
2)
3)

es
es
es
es

0.833818795185
0.834228809286
0.36783316514
0.622280377648

la
en
en
en
en

fila con indice

la posicin (9,
la posicin (9,
la posicin (9,
la posicin (9,

Pasando a otra fila...

Elementos de la fila con indice 10
Elemento en la posicin (10, 0)
Elemento en la posicin (10, 1)
Elemento en la posicin (10, 2)
Elemento en la posicin (10, 3)
Pasando a otra fila...

es
es
es
es

0.38523306417
0.15486906594
0.875121989766
0.434642544714

Reemplazando elementos al iterar sobre una matriz

Se pueden reemplazar elementos de una matriz en el esquema anterior, es decir, al iterar sobre sus filas
y columnas, de la misma forma en que se reemplazan elementos individuales fuera de alguna iteracin.
Es implica que hay que usar el operador de particin, [], dentro del for .. in .. ms interno. Por
ejemplo, para reemplazar todos los elementos de una matriz por ceros se hara lo siguiente.
1) Crear la matriz

In [89]: filas, columnas = 8, 3

matriz = rand(filas, columnas)
matriz
Out[89]:

array([[
[
[
[
[
[
[
[

6.27863252e-01,
2.53047680e-01,
6.55465212e-01,
5.22231227e-01,
5.14321000e-01,
4.45477802e-01,
4.85759883e-01,
4.71693258e-01,

5.21486377e-01,
6.74169283e-01,
4.43192707e-01,
2.56940062e-01,
9.81777857e-01,
1.20286045e-01,
5.90498377e-01,
8.04355646e-01,

8.37745670e-01],
1.78194693e-01],
6.43536900e-01],
4.19094016e-04],
2.90829165e-01],
5.39736460e-01],
9.56797864e-01],
9.18856025e-01]])

2) Obtener las filas y columnas y crear las listas de ndices

In [90]: forma = matriz.shape

filas, columnas = forma
filas_indices = range(filas)
columnas_indices = range(columnas)

3) Reemplazar elementos

In [92]: print 'Reemplazando elementos de una matriz por ceros'

for m in filas_indices:
# Iteracin sobre indices de las filas
for n in columnas_indices:
# Iteramos sobre los indices de las columnas
matriz[m, n] = 0

# Asignamos un cero al elemento en la fila m y

print 'La matriz reemplazada es:'

print matriz
Reemplazando elementos de una matriz por ceros
La matriz reemplazada es:
[[ 0. 0. 0.]
[ 0. 0. 0.]
[ 0. 0. 0.]
[ 0. 0. 0.]
[ 0. 0. 0.]
[ 0. 0. 0.]
[ 0. 0. 0.]
[ 0. 0. 0.]]
Los elementos de la matriz se pueden reempazar por valores dados por expresiones tan complejas
como se desee.
In [ ]: