📙 Matrices - Python#
1 - Ejemplos Matrices (Uso de numpy)
2 - Ejemplo Matrices (Implementación de todo lo visto)
import numpy as np
Ejemplos Matrices#
Uso de numpy entre otros.
En Python la creación de Matrices es más sencilla, su sintaxis es la siguiente:
Ejemplo 1
Crea una matriz con 12 números enteros y muestra en pantalla la matriz.
matriz_enteros = [[10, 12, 13],
[14, 15, 16],
[17, 18, 19],
[20, 21, 22]]
print(matriz_enteros)
[[10, 12, 13], [14, 15, 16], [17, 18, 19], [20, 21, 22]]
Esta es una disposición sin embargo una matriz de 12 elementos puede tener diferentes dimensiones, en este caso era 4x3, pero puede estar dispuesto de diferentes maneras 6x2, 2x6 y 3x4.
matriz_enteros = [[10, 12],
[13, 14],
[15, 16],
[17, 18],
[19, 20],
[21, 22]]
print(matriz_enteros)
[[10, 12], [13, 14], [15, 16], [17, 18], [19, 20], [21, 22]]
matriz_enteros = [[10, 12, 13, 14, 15, 16],
[17, 18, 19, 20,21, 22]]
print(matriz_enteros)
[[10, 12, 13, 14, 15, 16], [17, 18, 19, 20, 21, 22]]
matriz_enteros = [[10, 12, 13,14],
[15, 16, 17, 18],
[19, 20, 21, 22]]
print(matriz_enteros)
[[10, 12, 13, 14], [15, 16, 17, 18], [19, 20, 21, 22]]
Para acceder a un elemento usamos doble corchete [ ] y especificamos el indice, el cual inicia en 0 y termina en M-1, donde M es el tamaño de las filas y en N-1, donde N es el tamaño de las columnas.
[M]x[N]
Nota es importante tener en cuenta la dimensión previamente establecida, en una matriz de 2x6 no podemos llamar al elemento en la posición [2][6] porque esta fuera de la dimensión de la misma
# Indice 0
print(f'Elemento en indice 0: {matriz_enteros[0][2]}')
# Indice 1
print(f'Elemento en indice 1: {matriz_enteros[1][3]}')
# Indice 2
print(f'Elemento en indice 2: {matriz_enteros[2][2]}')
# Indice 3
print(f'Elemento en indice 3: {matriz_enteros[1][1]}')
# Indice 4
print(f'Elemento en indice 4: {matriz_enteros[2][3]}')
Elemento en indice 0: 13
Elemento en indice 1: 18
Elemento en indice 2: 21
Elemento en indice 3: 16
Elemento en indice 4: 22
Para modificar un valor utilizamos corchetes y el indice:
print(f'Matriz original: {matriz_enteros}')
# Modificando elemento en el indice 0
matriz_enteros[0][0] = 123
# Modificando elemento en el indice 4
matriz_enteros[2][3] = 123
print(f'Matriz modificada: {matriz_enteros}')
Matriz original: [[10, 12, 13, 14], [15, 16, 17, 18], [19, 20, 21, 22]]
Matriz modificada: [[123, 12, 13, 14], [15, 16, 17, 18], [19, 20, 21, 123]]
El tamaño de una matriz puede obtenerse utilizando la función len() de Python:
sin embargo veremos que este metodo es menos practico que el que veremos posteriormente con numpy
row=len(matriz_enteros)
print(f'Tamaño de las filas de la matriz: {row}')
col=len(matriz_enteros[0])
print(f'Tamaño de las columnas de la matriz: {col}')
Tamaño de las filas de la matriz: 3
Tamaño de las columnas de la matriz: 4
Recorriendo cada elemento de la matriz:
for i in range(0, len(matriz_enteros), 1):
for j in range(0, len(matriz_enteros[0]), 1):
print(f'Elemento en el indice {i}{j}: {matriz_enteros[i][j]}')
Elemento en el indice 00: 123
Elemento en el indice 01: 12
Elemento en el indice 02: 13
Elemento en el indice 03: 14
Elemento en el indice 10: 15
Elemento en el indice 11: 16
Elemento en el indice 12: 17
Elemento en el indice 13: 18
Elemento en el indice 20: 19
Elemento en el indice 21: 20
Elemento en el indice 22: 21
Elemento en el indice 23: 123
Ahora bien ¿Cómo sería con Numpy?
matriz = np.array([[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12]])
print(matriz)
[[ 1 2 3 4]
[ 5 6 7 8]
[ 9 10 11 12]]
¿Notas alguna diferencia? Sí, es la disposición estructural que muestra el print, una curiosidad de python, es que si no usas la librería numpy para generar matrices, Python toma asume que estas creando una lista de dos dimensiones, de forma que asumem que tienes una lista que contiene otra lista dentro de ella, teoricamente eso es una matriz, pero a nivel de programación es algo que debemos tener muy en cuenta.
Una ventaja de usar numpy sobre lo demás es lo avanzada que esta la librería para crear todo tipo de arreglos MxN dimensionales, como veremos a continuación:
# Crear una matriz de 12 elementos con dimensiones 3x4 con valores aleatorios en un rango definido
min=0 #rango minimo para introducir en la función random.randint
max=5 #rango maximo para introducir en la función random.randint
matriz_aleatoria = np.random.randint(min,max +1,(3,4))
print(matriz_aleatoria)
[[5 4 4 3]
[4 2 5 1]
[1 1 5 4]]
Además numpy nos entrega una forma más eficiente de conocer las dimensiones de una matriz
print(f'Dimensión de la matriz {matriz.shape}') #.shape es un metodo que nos permite conocer las dimensiones de una matriz de tipo numpy.ndarray
tipo=type(matriz)
print(f'Tipo de clase de la matriz {tipo}')
Dimensión de la matriz (3, 4)
Tipo de clase de la matriz <class 'numpy.ndarray'>
Ejemplo 2
Crea una lista con 6 nombres, imprime la lista original, luego recorre cada elemento y agrega el string _01, finalmente muestra el resultado final.
# Declarar variables
# Crear una matriz con 6 nombres
nombres = np.array([["Carlos"], ["Manuel"],["Alejandro"], ["Ana"], ["Luis"], ["Pepito"]])
# Imprimir la matriz original
print("Matriz original:")
print(nombres)
# Recorrer cada elemento y agregar el string "_01"
nombres_modificados = np.vectorize(lambda x: x + "_01")(nombres)
# Mostrar el resultado final
print("\nMatriz modificada:")
print(nombres_modificados)
Matriz original:
[['Carlos']
['Manuel']
['Alejandro']
['Ana']
['Luis']
['Pepito']]
Matriz modificada:
[['Carlos_01']
['Manuel_01']
['Alejandro_01']
['Ana_01']
['Luis_01']
['Pepito_01']]
Ejemplo 3
Crear una matriz de 8x8 con números aleatorios utilizando np.random.randint() y luego organizar los números de mayor a menor y de menor a mayor
# Crear matriz de 8x8 con números aleatorios entre 1 y 100
matriz = np.random.randint(1, 101, size=(8, 8))
# Imprimir la matriz original
print("Matriz original:")
print(matriz)
# Organizar los números de mayor a menor
matriz_mayor_a_menor = np.sort(matriz, axis=None)[::-1]
# Organizar los números de menor a mayor
matriz_menor_a_mayor = np.sort(matriz, axis=None)
# Reshape para obtener matrices de 8x8
matriz_mayor_a_menor = matriz_mayor_a_menor.reshape(8, 8)
matriz_menor_a_mayor = matriz_menor_a_mayor.reshape(8, 8)
# Imprimir las matrices organizadas
print("\nMatriz organizada de mayor a menor:")
print(matriz_mayor_a_menor)
print("\nMatriz organizada de menor a mayor:")
print(matriz_menor_a_mayor)
Matriz original:
[[52 31 8 11 16 9 81 34]
[68 47 35 14 78 58 89 50]
[87 48 22 21 14 48 83 29]
[40 16 93 86 51 68 21 72]
[97 96 99 44 11 23 23 19]
[82 27 70 18 51 7 70 14]
[13 23 86 10 72 30 34 62]
[33 2 26 36 18 72 17 96]]
Matriz organizada de mayor a menor:
[[99 97 96 96 93 89 87 86]
[86 83 82 81 78 72 72 72]
[70 70 68 68 62 58 52 51]
[51 50 48 48 47 44 40 36]
[35 34 34 33 31 30 29 27]
[26 23 23 23 22 21 21 19]
[18 18 17 16 16 14 14 14]
[13 11 11 10 9 8 7 2]]
Matriz organizada de menor a mayor:
[[ 2 7 8 9 10 11 11 13]
[14 14 14 16 16 17 18 18]
[19 21 21 22 23 23 23 26]
[27 29 30 31 33 34 34 35]
[36 40 44 47 48 48 50 51]
[51 52 58 62 68 68 70 70]
[72 72 72 78 81 82 83 86]
[86 87 89 93 96 96 97 99]]
Ejemplo 4
En este caso, vamos a crear una función que tome una matriz cuadrada y verifique si es simétrica. Una matriz es simétrica si es igual a su propia traspuesta.
def es_simetrica(matriz):
"""
Verifica si una matriz es simétrica.
Args:
- matriz: np.ndarray, la matriz a verificar
Returns:
- bool: True si la matriz es simétrica, False en caso contrario
"""
# Verificar si la matriz es cuadrada
filas, columnas = matriz.shape
if filas != columnas:
return False
# Verificar si la matriz es igual a su traspuesta
return np.array_equal(matriz, matriz.T)
# Crear una matriz para el ejemplo
matriz_ejemplo = np.array([[1, 2, 3],
[2, 4, 5],
[3, 5, 6]])
# Llamar a la función para verificar si la matriz es simétrica
if es_simetrica(matriz_ejemplo):
print("La matriz es simétrica.")
else:
print("La matriz no es simétrica.")
La matriz es simétrica.
Ejemplo 4
En este caso, crearemos una función que toma dos matrices y verifica si son multiplicables. Si son multiplicables, la función devolverá el resultado de la multiplicación; de lo contrario, devolverá un mensaje indicando que las matrices no pueden multiplicarse.
def multiplicar_matrices(matriz_a, matriz_b):
"""
Multiplica dos matrices y devuelve el resultado si son multiplicables.
Args:
- matriz_a: np.ndarray, la primera matriz
- matriz_b: np.ndarray, la segunda matriz
Returns:
- np.ndarray or str: El resultado de la multiplicación o un mensaje de error
"""
filas_a, columnas_a = matriz_a.shape
filas_b, columnas_b = matriz_b.shape
# Verificar si las matrices son multiplicables
if columnas_a != filas_b:
return "Error: Las matrices no son multiplicables."
# Inicializar la matriz resultado con ceros
resultado = np.zeros((filas_a, columnas_b))
# Realizar la multiplicación de matrices
for i in range(filas_a):
for j in range(columnas_b):
for k in range(columnas_a):
resultado[i, j] += matriz_a[i, k] * matriz_b[k, j]
return resultado
# Crear dos matrices para el ejemplo
matriz_a = np.array([[1, 2, 3],
[4, 5, 6]])
matriz_b = np.array([[7, 8],
[9, 10],
[11, 12]])
# Llamar a la función para multiplicar las matrices
resultado_multiplicacion = multiplicar_matrices(matriz_a, matriz_b)
# Imprimir el resultado o el mensaje de error
if isinstance(resultado_multiplicacion, np.ndarray):
print("Resultado de la multiplicación:")
print(resultado_multiplicacion)
else:
print(resultado_multiplicacion)
Resultado de la multiplicación:
[[ 58. 64.]
[139. 154.]]
Ejemplo 5
Vamos a crear una función que, dada una matriz cuadrada, encuentra el producto acumulativo de los elementos a lo largo de las diagonales principales y secundarias. Este ejercicio implicará la manipulación de matrices, ciclos, funciones y condicionales.
def producto_diagonales(matriz):
"""
Encuentra el producto acumulativo de los elementos a lo largo de las diagonales principales y secundarias.
Args:
- matriz: np.ndarray, la matriz cuadrada de entrada
Returns:
- int: El producto acumulativo de los elementos a lo largo de las diagonales
"""
filas, columnas = matriz.shape
# Verificar si la matriz es cuadrada
if filas != columnas:
return "Error: La matriz no es cuadrada."
# Inicializar productos acumulativos
producto_principal = 1
producto_secundaria = 1
# Calcular el producto acumulativo de la diagonal principal y secundaria
for i in range(filas):
producto_principal *= matriz[i, i]
producto_secundaria *= matriz[i, filas - 1 - i]
return producto_principal, producto_secundaria
# Crear una matriz cuadrada para el ejemplo
matriz_ejemplo = np.array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
# Llamar a la función para encontrar el producto acumulativo
resultado_producto_diagonales = producto_diagonales(matriz_ejemplo)
# Imprimir el resultado o el mensaje de error
if isinstance(resultado_producto_diagonales, tuple):
producto_principal, producto_secundaria = resultado_producto_diagonales
print("Producto acumulativo de la diagonal principal:", producto_principal)
print("Producto acumulativo de la diagonal secundaria:", producto_secundaria)
else:
print(resultado_producto_diagonales)
Producto acumulativo de la diagonal principal: 45
Producto acumulativo de la diagonal secundaria: 105
Ejemplo 6
Vamos a crear una función que encuentre el número máximo en cada fila de una matriz y calcule la diferencia absoluta máxima entre estos números máximos.
def diferencia_absoluta_maxima(matriz):
"""
Encuentra la diferencia absoluta máxima entre los números máximos de cada fila de una matriz.
Args:
- matriz: np.ndarray, la matriz de entrada
Returns:
- int: La diferencia absoluta máxima entre los números máximos de cada fila
"""
filas, columnas = matriz.shape
# Verificar si la matriz tiene al menos dos filas
if filas < 2:
return "Error: La matriz debe tener al menos dos filas."
# Inicializar la diferencia absoluta máxima
max_diferencia_absoluta = 0
# Calcular la diferencia absoluta máxima entre los números máximos de cada fila
for i in range(filas):
max_numero_fila = np.max(matriz[i, :])
for j in range(i + 1, filas):
max_numero_otra_fila = np.max(matriz[j, :])
diferencia_absoluta = abs(max_numero_fila - max_numero_otra_fila)
if diferencia_absoluta > max_diferencia_absoluta:
max_diferencia_absoluta = diferencia_absoluta
return max_diferencia_absoluta
# Crear una matriz para el ejemplo
matriz_ejemplo = np.array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9],
[10, 11, 12]])
# Llamar a la función para encontrar la diferencia absoluta máxima
resultado_diferencia_absoluta = diferencia_absoluta_maxima(matriz_ejemplo)
# Imprimir el resultado o el mensaje de error
print("Diferencia absoluta máxima entre los números máximos de cada fila:", resultado_diferencia_absoluta)
Diferencia absoluta máxima entre los números máximos de cada fila: 9
Ejemplo 7
Vamos a crear una función que tome una matriz cuadrada y verifique si es una matriz antisimétrica. Una matriz antisimétrica es aquella en la que la transpuesta de la matriz es igual a su negación. La diagonal principal de una matriz antisimétrica debe consistir en ceros.
def es_antisimetrica(matriz):
"""
Verifica si una matriz es antisimétrica.
Args:
- matriz: np.ndarray, la matriz cuadrada de entrada
Returns:
- bool: True si la matriz es antisimétrica, False en caso contrario
"""
filas, columnas = matriz.shape
# Verificar si la matriz es cuadrada
if filas != columnas:
return False
# Verificar si la matriz es antisimétrica
return np.array_equal(matriz, -matriz.T)
# Crear una matriz para el ejemplo (matriz antisimétrica)
matriz_antisimetrica = np.array([[0, 1, -2],
[-1, 0, 3],
[2, -3, 0]])
# Crear otra matriz para el ejemplo (matriz no antisimétrica)
matriz_no_antisimetrica = np.array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
# Llamar a la función para verificar si las matrices son antisimétricas
resultado_antisimetrica = es_antisimetrica(matriz_antisimetrica)
resultado_no_antisimetrica = es_antisimetrica(matriz_no_antisimetrica)
# Imprimir los resultados
print("¿La matriz es antisimétrica? (esperado: True):", resultado_antisimetrica)
print("¿La otra matriz es antisimétrica? (esperado: False):", resultado_no_antisimetrica)
¿La matriz es antisimétrica? (esperado: True): True
¿La otra matriz es antisimétrica? (esperado: False): False