MATRICES CON LISTAS

MATRIZ CON LISTAS

La matriz es, por ejemplo 2 filas y 2 columnas:
>>> M=[ [1, 2], [3, 4] ]
>>> M[0] # Fila 0
[1,2]
>>> M[1][0] # Fila 1, Columna 0
def leer_matriz():
print('Lectura de la matriz')
nf = int(input('Numero de filas= '))
nc = int(input('Numero de columnas= '))
#Creacion de la matriz nula
M = []
for i in range(nf):
M.append([0]* nc)
# lectura de elementos
for f in range(nf):
for c in range(nc): # f reemplaza a {0} y c a {1}:
M[f][c] = float(input(' elemento ({0},{1}): '.format(f,c)))
 MATRIZ CON LISTAS
def mostrar_matriz(M):
print(‘\nMatriz’)
nf = len(M) # Número de filas
nc = len(M[0]) # Número de columnas
for f in range(nf):
for c in range(nc):
print(M[f][c],end='\t') # en la misma línea, tabulados
print('') # Salto de línea

LLAMADO:
>>> W=leer_matriz()
>>> mostrar_matriz(W)
FUNCIONES
 FUNCIONES
Sintaxis:
def nombre(arg1, arg2, ...):
"“”cadena de documentación"""
# se accede a la documentación con nombre.__doc__
sentencias
return expression # opcional
Ejemplo:
def cubo(x):
"""Retorna el cubo de un número dado""“
return x * x * x
Llamado a la función:
>>> cubo(5)
125
>>> cubo
<function cubo at 0x7fa57ec54bf8>
>>> type(cubo)
<class 'function'>
 FUNCIONES
>>> cubo.__doc__ # muestra la cadena de documentación
'Retorna el cubo de un número dado'
>>> help(cubo)
Help on function cubo in module __main__:

cubo(x)
Retorna el cubo de x
>>> dir(cubo) # muestra atributos
['__annotations__', '__call__', '__class__', '__closure__',
'__code__', '__defaults__', '__delattr__', '__dict__', '__dir__',
'__doc__', '__eq__', '__format__', '__ge__', '__get__',
'__getattribute__', '__globals__', '__gt__', '__hash__', '__init__',
'__init_subclass__', '__kwdefaults__', '__le__', '__lt__',
'__module__', '__name__', '__ne__', '__new__', '__qualname__',
'__reduce__', '__reduce_ex__', '__repr__', '__setattr__',
'__sizeof__', '__str__', '__subclasshook__']
 PARÁMETROS DE FUNCIONES

• Los argumentos inmutables (enteros, floats, strings,

tuplas) se pasan por valor. Es decir, se clona una copia
y se pasa a la función, y el original no se puede
modificar dentro de la función.
• Los argumentos mutables (listas, diccionarios, conjuntos
e instancias de clases) se pasan por referencia (se
envía su dirección de memoria). Es decir, se pueden
modificar dentro de la función.
 PARÁMETROS DE FUNCIONES CON VALORES POR
DEFECTO

Se puede asignar un valor por defecto a los parámetros de

funciones.
def suma1(x1, x2 = 4, x3 = 5):
# x1 es requerido, x2 y x3 son opcionales
"""Retorna la suma de todos los argumentos"""
return x1 + x2 + x3
>>> print(suma1(1, 2, 3))
6
>>> print(suma1(1, 2)) # x3 por defecto es 5
8
>>> print(suma1(1)) # por defecto x2=4, x3=5
10
>>> print(suma1())
TypeError: suma() takes at least 1 argument (0 given)
 ARGUMENTOS POSICIONALES Y NOMINALES
Las funciones en Python permiten argumentos posicionales y
nombrados (especificando el nombre).
Normalmente se pasan los argumentos por posición de izquierda
a derecha (posicional).
def suma2(x1, x2 = 4, x3 = 5):
"""Return the sum of all the arguments"""
return x1 + x2 + x3
>>> print(suma2(x2 = 2, x1 = 1, x3 = 3))
6
>>> print(suma2(x2 = 2, x1 = 1)) # x3=5 por defecto
8
>>> print(suma2(x1 = 1)) # por defecto x2 = 4 y x3 = 5
10
>>> print(suma2(1, x3 = 3)) # x2 = 4 por defecto
8
>>> print(suma2(x2 = 2))
TypeError: suma() missing 1 required positional argument: 'x1'
Numpy
 Que es NumPy?

• NumPy es el paquete fundamental para

computación científica con Python.
• Contiene:
– Arreglos N-dimensionales con métodos avanzados
– Funciones de algebra lineal
– Transformadas de Fourier
– Numeros random avanzados
– Herramientas para integración con código C/C++/
Fortran
 NumPy documentación

• Documentación oficial
– http://docs.scipy.org/doc/
• Libro de NumPy
– http://web.mit.edu/dvp/Public/numpybook.pdf
• Ejemplos
– https://docs.scipy.org/doc/numpy/reference/routines.html
 Arrays – Numerical Python (Numpy)
Las listas sirven para arreglos uni-dimensionales de pocos datos
>>> a = [1,3,5,7,9] >>> print(b[1][2:4])
>>> print(a[2:4]) [6, 8]
>>> a = [1,3,5,7,9]
[5, 7] >>> b = [3,5,6,7,9]
>>> b = [[1, 3, 5, 7, 9], [2, 4, 6, 8, 10]] >>> c = a + b
>>> print(b[0]) >>> print c
[1, 3, 5, 7, 9] [1, 3, 5, 7, 9, 3, 5, 6, 7, 9]

• No pueden trabajar con operadores aritméticos (+, -, *, /, …)

• Se necesita arreglos con operaciones eficientes y herramientas
multidimensionales
• Numpy
• En general: >>> import numpy as np
• Similar a listas, con más capacidades, excepto el tamaño fijo
 Numpy – Creación de arreglos

• Hay varias maneras de inicializar un nuevo

arreglo en numpy, por ejemplo:
– Una lista o tupla Python
– Usando funciones para generar arreglos
numpy, tales como arange, linspace, etc.
 Numpy – Crear vectores

• Desde listas: numpy.array

# Como vector desde lista

>>> a = np.array([1,3,5,7,9])
>>> b = np.array([3,5,6,7,9])
>>> c = a + b
>>> print(c)
[4, 8, 11, 14, 18]
>>> type(c) # tipo de dato
(<type 'numpy.ndarray'>)
>>> c.shape # forma
(5,)
 Numpy – Crear matrices
>>> l = [[1, 2, 3], [3, 6, 9], [2, 4, 6]] # crea una lista
>>> a = np.array(l) # convierte la lista en array
>>>print(a)
[[1 2 3]
[3 6 9]
[2 4 6]]
>>> a.shape #dimension (forma)
(3, 3)
>>> print(a.dtype) # muestra tipo de un array
int32
# o crear directamente como una matriz
>>> M = np.array([[1, 2], [3, 4]])
>>> M.shape
(2,2)
>>> M.dtype
dtype('int32')
 Numpy – Crear matrices
#Solo de un tipo de dato
>>> M[0,0] = "hello"
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: invalid literal for long() with base 10: 'hello‘
# Especificando el tipo de dato
>>> M = np.array([[1, 2], [3, 4]], dtype=complex)
>>> M
array([[ 1.+0.j, 2.+0.j],
[ 3.+0.j, 4.+0.j]])
 Numpy – uso de Matrices
>>> print(a)
[[1 2 3]
[3 6 9] ]
>>> print(a[0]) # igual que en una lista de listas, la fila 0
[1 2 3]
>>> print(a[1, 2]) # una coma separa los índices
9
>>> print(a[1, 1:3]) # una parte de la matriz
[6 9]
>>> print(a[:,1]) # la columna 1
[2 6]
>>> a[1, 2] = 7 # modifica un elemento
>>> print(a)
[[1 2 3]
[3 6 7] ]
>>> a[:, 0] = [0, 9] # modifica la columna 0
>>> print(a)
[[0 2 3]
[9 6 7] ]
 Numpy – Crear arrays
• Funciones de Generación

>>> x = np.arange(0, 10, 1) # similar a range, argumentos:

inicial, final-1, incremento
>>> x
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> np.linspace(0, 10, 12) # inicial, final, numero de elementos
array([ 0. , 0.90909091, 1.81818182, 2.72727273,
3.63636364, 4.54545455, 5.45454545, 6.36363636,
7.27272727, 8.18181818, 9.09090909, 10. ])
>>> np.logspace(0, 10, 5, base=np.e) # notación exponencial
array([1.00000000e+00, 1.21824940e+01, 1.48413159e+02,
1.80804241e+03, 2.20264658e+04])
 Numpy – Crear arrays
>>> np.diag([1,2,3]) # Matriz diagonal
array([[1, 0, 0],
[0, 2, 0],
[0, 0, 3]])
>>> b = np.zeros(5) # Vector de ceros
>>> print(b)
[0., 0., 0., 0., 0.]
>>> b.dtype
dtype(‘float64’)
>>> v = np.zeros(3, dtype=np.int)
>>> v
array([0, 0, 0])
>>> v.dtype
dtype(‘int32’)
>>> c = np.ones((3,3)) # Matriz de unos
>>> c
array([[ 1., 1., 1.],
[ 1., 1., 1.],
[ 1., 1., 1.]])
 Numpy – creacion y uso de arrays
>>> d = np.arange(5) # similar a range()
>>> print(d)
[0 1 2 3 4]
>>> d[1] = 9.7
>>> print(d) # array mantiene su tipo, al cambiar elementos
[0 9 2 3 4]
>>> print(d*0.4) # operaciones crean un nuevo array y tipo
[ 0. 3.6 0.8 1.2 1.6]
>>> d = np.arange(5, dtype=np.float)
>>> print(d)
[ 0. 1. 2. 3. 4.]
>>> np.arange(3, 7, 0.5) # arbitrarios inicio, fin e incremento
array([ 3. , 3.5, 4. , 4.5, 5. , 5.5, 6. , 6.5])
 Numpy – array creacion y uso

>>> x, y = np.mgrid[0:3, 0:3] # como meshgrid de MATLAB

>>> x
array([[0, 0, 0],
[1, 1, 1],
[2, 2, 2]])
>>> y
array([[0, 1, 2],
[0, 1, 2],
[0, 1, 2]])
>>> np.random.rand(2,3)
array([[0.53182759, 0.63440096, 0.84943179],
[0.72445532, 0.61102351, 0.72244338]])
 Numpy – array creación y uso
Dos ndarrays son mutables y pueden ser vistos en la misma memoria:
>>> x = np.array([1,2,3,4])
>>> y = x #asignación
>>> x is y # comparación de igualdad
True
>>> id(x), id(y)
(139814289111920, 139814289111920)
>>> x[0] = 9
>>> y
array([9, 2, 3, 4])
>>> x[0] = 1
>>> z = x[:]
>>> x is z
False
>>> id(x), id(z)
(139814289111920, 139814289112080)
>>> x[0] = 8
>>> z
array([8, 2, 3, 4])
 Numpy – array creación y uso
Dos ndarrays son mutables y pueden ser vistos en la misma memoria:

>>> x = np.array([1,2,3,4])
>>> y = x.copy()
>>> x is y
False
>>> id(x), id(y)
(139814289111920, 139814289111840)
>>> x[0] = 9
>>> x
array([9, 2, 3, 4])
>>> y
array([1, 2, 3, 4])
 Numpy – array creación y uso
>>> a = np.arange(4.0)
>> a
array([0., 1., 2., 3.])
>>> b = a * 23.4
>>> b
array([ 0. , 23.4, 46.8, 70.2])
>>> c = b/(a+1)
>>> c += 10
>>> print c
[ 10. 21.7 25.6 27.55]
>>> arr = np.arange(100, 200)
>>> seleccion = [5, 25, 50, 75, -5]
>>> print(arr[seleccion]) #puede usar lista enteros como índices
[105, 125, 150, 175, 195]
 Numpy – array creación y uso
>>> arr = np.arange(10, 20)
>> arr
array([10, 11, 12, 13, 14, 15, 16, 17, 18, 19])
>>> div_por_3 = arr%3 == 0 # comparación produce un
arreglo boolean
>>> print(div_por_3)
[ False False True False False True False False True False]
>>> print(arr[div_por_3]) # puede usarse una lista boolean
como indices (considera los True)
[12 15 18]
# Cambiando las dimensiones con reshape
>>> arr = np.arange(10, 20) . reshape((2,5))
[[10 11 12 13 14]
[15 16 17 18 19]]
 Numpy – métodos array
>>> arr.sum() # sumatoria
145
>>> arr.mean() # promedio
14.5
>>> arr.std() # desviación estándar
2.8722813232690143
>>> arr.max() # mayor
19
>>> arr.min() # menor
10
>>> div_by_3.all() # todos son True
False
>>> div_by_3.any() # alguno es True
True
>>> div_by_3.sum() # sumatoria (No.) de True
3
>>> div_by_3.nonzero() # posiciones de True
(array([2, 5, 8]), dtype=int64),)
 Numpy – métodos array - sorting

>>> a = np.array([4.5, 2.3, 6.7, 1.2, 1.8, 5.5])

>>> a.sort() # ordena el array físicamente, lo modifica
>>> print(a)
[ 1.2 1.8 2.3 4.5 5.5 6.7]
>>> x = np.array([4.5, 2.3, 6.7, 1.2, 1.8, 5.5])
>>> np.sort(x) # ordena sin modificar el array x
array([ 1.2, 1.8, 2.3, 4.5, 5.5, 6.7])
>>> print(x)
[ 4.5 2.3 6.7 1.2 1.8 5.5]
>>> s = x.argsort() # indice de elementos por orden
>>> s
array([3, 4, 1, 0, 5, 2])
>>> x[s] # muestra x ordenado, según s
array([ 1.2, 1.8, 2.3, 4.5, 5.5, 6.7])
 Numpy – funciones array

• La mayoría de los métodos array tienen funciones

equivalentes
>>> arr.sum()
45
>>> np.sum(arr)
45
• Ufuncs provee muchas operaciones elemento-por-
elemento matemáticas, trigonométricas, etc.
– Por ejemplo, add(x1, x2), abs(x), log10(x), sin(x), …

• Ver http://numpy.scipy.org
 Funciones NumPy

abs() min()
exp() max()
… multiply(arr,num)
add() polyfit()
binomial() randint()
cumprod() transpose()
cumsum() …
floor()
histogram()
30
 Numpy – operaciones array
>>> a = np.array([[1.0, 2.0], [4.0, 3.0]])
>>> print(a)
[[ 1. 2.]
[ 3. 4.]]
>>> a.transpose()
array([[ 1., 3.],
[ 2., 4.]])
>>> inv(a) # no funciona
array([[-2. , 1. ],
[ 1.5, -0.5]])
>>> u = np.eye(2) # matriz identidad 2x2
>>> u
array([[ 1., 0.],
[ 0., 1.]])
>>> j = np.array([[0.0, -1.0], [1.0, 0.0]])
>>> np.dot (j, j) # matriz producto
array([[-1., 0.],
[ 0., -1.]])
 Numpy – operaciones elemento por
elemento - array
>>> a = np.array([1,2,3], float)
>>> b = np.array([5,2,6], float)
>>> a + b
array([6., 4., 9.])
>>> a – b
array([-4., 0., -3.])
>>> a * b
array([5., 4., 18.])
>>> b / a
array([5., 1., 2.])
>>> a % b
array([1., 0., 3.])
>>> b**a
array([5., 4., 216.])
 Numpy – operaciones elemento por
elemento - array
>>> a = np.array([[1, 2], [3, 4], [5, 6]], float)
>>> b = np.array([-1, 3], float)
>>> a
array([[ 1., 2.],
[ 3., 4.],
[ 5., 6.]])
>>> b
array([-1., 3.])
>>> a + b
array([[ 0., 5.],
[ 2., 7.],
[ 4., 9.]])
Numpy – array operaciones elemento por
elemento
>>> a = np.array([[1, 2], [3, 4], [5, 6]], float)
>>> b = np.array([-1, 3], float)

>>> a * a
array([[ 1., 4.],
[ 9., 16.],
[ 25., 36.]])
>>> b * b
array([ 1., 9.])
>>> a * b
array([[ -1., 6.],
[ -3., 12.],
[ -5., 18.]])
 Numpy – arrays, matrices
Para array de 2 dimensiones NumPy define la clase matriz en
el módulo matrix. Los objects son creados con matrix() o mat()
or convertidos desde un array con el método asmatrix().
>>> m = np.mat([[1,2],[3,4]])
# otra opción
>>> a = np.array([[1,2],[3,4]])
>>> m = np.mat(a)
# otra opción
>>> a = np.array([[1,2],[3,4]])
>>> m = np.asmatrix(a)

m = mat(a) crea una copia del array 'a'. Cambiar valores en ‘a’
no afectará a 'm'.
El método m = asmatrix(a) retorna una nueva referencia al mismo
dato, cambiar valores en 'a' afectará a 'm'.
 Numpy – matrices
Las operaciones en array y matrix pueden ser distintas!
>>> a = np.array([[1,2],[3,4]])
>>> m = np.mat(a) # convierte 2-d array a matriz
>>> m
matrix([[1, 2],
[3, 4]])
>>> m = np.matrix([[1, 2], [3, 4]]) # crea matriz m
>>> a[0] # el resultado es 1-dimensional
array([1, 2])
>>> m[0] # el resultado is 2-dimensional
matrix([[1, 2]])
>>> a*a # elemento-por-elemento multiplicación
array([[ 1, 4], [ 9, 16]])
>>> m*m # (algebraica) matriz multiplicación
matrix([[ 7, 10], [15, 22]])
 Numpy – matrices
Las operaciones en array y matrix pueden ser distintas!

>>> a**3 # element-por elemento potencia

array([[ 1, 8], [27, 64]], dtype=int32)
>>> m**3 # multiplicación de matrices m*m*m
matrix([[ 37, 54], [ 81, 118]])
>>> m.T # transpuesta de la matriz
matrix([[1, 3], [2, 4]])
>>> m.H # conjugada transpuesta (difiere .T para
matrices complejas)
matrix([[1, 3], [2, 4]])
>>> m.I # matriz inversa
matrix([[-2. , 1. ], [ 1.5, -0.5]])
 PROBLEMAS

1. PROBAR LOS EJEMPLOS (DE CADA CASO

PRESENTADO EN CADA DIAPOSITIVA)
2. SUMAR DOS MATRICES CON LISTAS

38
GRACIAS