Fundamentos de programación

…Arreglos N-dimensionales
 …array

a=numpy.array([[23,45,63],[72,81,91],
[56,64,37],[34,75,26]],int)
[ 0 1 2 3 4 5 6 7 8 9]
b = numpy.arange(10, dtype = int)
[[ 0. 0. 0.]
[ 0. 0. 0.]]

c = numpy.zeros((2,3), dtype=float)
[[56 64]
[34 75]]
d = a[2:,:2]
 Recorrer un array

iteracion i j a(i,j)
[filas,columnas]=a.shape
for i in range (filas): 1 0 0 23
2 0 1 45
for j in range (columnas): 3 0 2 63
print (a[i,j]) 4 1 0 72
5 1 1 81
6 1 2 91
7 2 0 56
8 2 1 64
9 2 2 37
10 3 0 34
11 3 1 75
12 3 2 26
 minimo maximo

a=numpy.array([[23,45,63],[72,81,91],
[56,64,37],[34,75,26]],int)
print(a.min())
print(a.max())
print(a.argmin())
print(a.argmax()//len(a[0]))
print(a.argmax())
print(a.argmax()%len(a[0]))
 ordenar

a=numpy.array([[23,45,63],[72,81,91],
[56,64,37],[34,75,26]],int)

a = numpy.sort (a)
print(a)

[[23 45 63]
[72 81 91]
[37 56 64]
[26 34 75]]
 ordenar

a=numpy.array([[23,45,63],[72,81,91],
[56,64,37],[34,75,26]],int)

a = numpy.sort (a, axis=0)

print(a)

[[23 45 26]
[34 64 37]
[56 75 63]
[72 81 91]]
 ordenar

a=numpy.array([[23,45,63],[72,81,91],
[56,64,37],[34,75,26]],int)

a = numpy.sort (a, axis=None)

print(a)

[23 26 34 37 45 56 63 64 72 75 81 91]
 ordenar

a=numpy.array([[23,45,63],[72,81,91],
[56,64,37],[34,75,26]],int)

[filas,columnas]=a.shape
a = numpy.sort(a, axis=None)
a = a.reshape(filas,columnas)
print(a)
[[23 26 34]
[37 45 56]
[63 64 72]
[75 81 91]]
 unique

[[23 45 23]
[72 81 91]
a = [56 91 37]
[34 91 26]]

a=numpy.array([[23,45,23],[72,81,91],
[56,91,37],[34,91,26]],int)
a = numpy.unique(a)
print(a)

[23 26 34 37 45 56 72 81 91]
 Comparaciones
Las operaciones booleanas sirven para comparar matrices elemento por
elemento

a = numpy.array([12, 1, 4, 7], dtype=float)

b = numpy.array([10, 6, 4, 9], dtype=float)

print(a>b) [True False False False]

print(a==b) [False False True False]
print(a<b) [False True False True ]
print(a>=b) [True False True False]
print(a<=b) [False True True True ]
print(a>10) [True False False False]
print(b>10) [False False False False]
print(a+b < 10) [False True True False]
print(a%2 == 0) [True False True False]
 Comparaciones
any devuelve True si cualquier elemento del arreglo es verdadero
all devuelve True si todos los elementos del arreglo es verdadero

a = numpy.array([12, 1, 4, 7], dtype=float)

b = numpy.array([10, 6, 4, 9], dtype=float)

print(any(a>b)) True
print(all(a>b)) False
print(any(a == 1)) True
print(all(b%2 == 0)) False
print(all(b >= 4)) True
 Comparaciones
where crea un nuevo arreglo a partir de un filtro booleano.

sintaxis: where(arregloBooleano, arregloPorVerdadero, arregloPorFalso)

a = numpy.array([12, 1, 4, 7], dtype=float)

b = numpy.array([10, 6, 4, 9], dtype=float)

print(numpy.where (a>5,b,a)) [ 10. 1. 4. 9.]

print(numpy.where (a>5,3,a)) [ 3. 1. 4. 3.]
print(numpy.where (b%2==0,b,0)) [ 10. 6. 4. 0.]
 where
Si where solamente recibe un arreglo booleano, da como resultado una
estructura con todos los indices que cumplen dicho arreglo

a=numpy.array([ [23,45,63],
[72,81,91],
[56,91,37],
[34,91,26] ],int)

q = numpy.where(a==91)
print (q)

(array([1, 2, 3], dtype=int64), array([2, 1, 1], dtype=int64))

fila = q[[0][0]]
fila = fila[0]
columna = q[[1][0]]
columna = columna[0]
print( fila,columna)
 indexacion booleana
Consiste en crear una matriz que solamente contenga los elementos cuyos
indices coincidan con los indices de los elementos verdaderos de una matriz
booleana

a = numpy.array([12, 1, 4, 7], dtype=float)

b = numpy.array([10, 6, 4, 9], dtype=float)
matrizBooleana = numpy.array([True,False,True,True])

c = a[ matrizBooleana ]
a = [ 12. 1. 4. 7.]

matrizBooleana =[True False True True]

c -> [ 12. 4. 7.]

 indexacion booleana
Consiste en crear una matriz que solamente contenga los elementos cuyos
indices coincidan con los indices de los elementos verdaderos de una matriz
booleana

a = numpy.array([12, 1, 4, 7], dtype=float)

b = numpy.array([10, 6, 4, 9], dtype=float)
matrizBooleana = numpy.array([True,False,True,True])

c = a[a>5] [ 12. 7.]

c = a[b >5] [ 12. 1. 7.]
c = a[a==6] []
 Ejercicio
Crear un programa que muestre en pantalla los nombres de las personas con
sobrepeso (IMC ≥ 25.00). Para esto se tiene los datos de las personas en 3
arreglos: nombres, pesos, alturas.

nombres= numpy.array([['Juan'],['Maria'],['Pedro'],['Carla']])
pesos = numpy.array([[72],[62],[80],[65]],float)
alturas= numpy.array([[1.71],[1.62],[1.72],[1.59]],float)

sobrepeso = nombres[pesos/(alturas*alturas) > 25.0]

['Pedro' 'Carla']
 Ejercicio
Sumar los elementos pares de a

a=numpy.array([[23,45,63],[72,81,91],
[56,64,37],[34,75,26]],int)

suma = a[a%2==0].sum() pares = a[a%2==0]

suma = pares.sum()
 Aleatorios

a = numpy.random.rand(5)
b = numpy.random.rand(2,3)
c = numpy.random.randint(1,3, size= 5)
d = numpy.random.randint(3, size= (2,3))

[ 0.86843528 0.28255917 0.57857949 0.56898998 0.13068218]

[[ 0.79643603 0.90033173 0.93724948]

[ 0.6383312 0.93786837 0.65522225]]

[1 2 2 1 2]

[[0 0 0]
[2 0 1]]