Transposición y Suma de Matrices en Python

Numpy facilita mucho el trabajo, eso es un hecho, sin embargo considero que estos temas básicos se deben enseñar de la manera tradicional, por ejemplo, para sumar dos matrices, hay que sumar escalar por escalar, de la manera tradicional, como se hace en C/C++ o a mano. Hacer esto desarrolla la lógica algorítmica.

Aca les presento el primer ejemplo de suma del video pero escalar por escalar:

#inicializacion de arrays, uso Numpy solo para iniciarlizar
a = np.array([[1,2],[3,4],[5,6]])
b = np.array([[6,5],[4,3],[2,1]])
c = np.array([[0,0],[0,0],[0,0]])

#suma escalar por escalar con bucles while anidados
i = 0
while (i<3):
  j = 0
  while (j<2):
    c[i][j] = a[i][j] + b[i][j]
    j = j + 1
  i = i + 1

print(a)
print(b)
print(c)```

Los invito a hacer los ejercicios de esta manera, les desarrollara mucha lógica.

Trasposición:

• Definimos a la matriz transpuesta como la matriz a la que invertimos las posiciones, es decir invertimos las filas por las columnas. Si teníamos una matriz de dimensiones mxn su transpuesta será una matriz de dimensión nxm
• Un tensor también se puede transponer en este caso se intercambiaran los elementos de manera que la jerarquía quede invertida. Sea un tensor de mxnxp el tensor transpuesto tendrá una dimensión de pxnxm
• El arreglo transpuesto se encuentra guardado en el atributo T
• Por convención denotamos al transpuesto con un subíndice _t
• Sintaxis
  A_t = A.T

Nota:

• Sea A una matriz y A_t su transpuesta A=A_t_t

Suma de matrices
Está definida para matrices de las mismas dimensiones y será una matriz cuyos elementos serán la sumas de los elementos que se encuentran en la misma posición de las matrices a sumar

Nota:

• Si sumamos (en python) una matriz y un escalar obtendremos una matriz en la que los elementos son la suma de cada elemento de la matriz original con el escalar

Les comparto el código del escalar, el vector, la matriz y el tensor para que no tengan que escribirlo desde 0

scalar = 5.679
vector = np.array([3,4,5,6])
matriz = np.array([[1,2],[3,4],[5,6]])
tensor = np.array([
    [[1,2,3,30], [4,5,6,31], [7,8,9,32]],
    [[11,12,13,33], [14,15,16,34], [17,18,19,35]],
    [[21,22,23,36], [24,25,26,37], [27,28,29,38]]
])

print(matrix, " + ", matrix_t, " = ", final, sep = "\n\n")

[[7 3 4 9 1]
 [0 3 2 9 2]
 [8 2 4 1 0]
 [5 2 3 8 7]
 [1 3 2 4 5]]

 + 

[[7 0 8 5 1]
 [3 3 2 2 3]
 [4 2 4 3 2]
 [9 9 1 8 4]
 [1 2 0 7 5]]

 = 

[[14  3 12 14  2]
 [ 3  6  4 11  5]
 [12  4  8  4  2]
 [14 11  4 16 11]
 [ 2  5  2 11 10]]

Hola para quienes sean curiosos como yo, aquí les dejo la manera “a pie” de hacer la transposición de matrices, con una List Comprehension:

Recordando lo importante de conocer, en la medida de lo posible, los fundamentos algorítmicos de la funciones pertenecientes a las librerías que podamos utilizar, mas allá incluso del lenguaje que utilicemos.
Saludos a todos.!

Solo para aclarar, las propiedades y operaciones de los tipos de arreglos(escalares, matrices, etc) solo funcionan en python cuando estamos trabajando un objeto tipo array.
Es decir, la propiedad .shape, ndim y en general las operaciones con matrices, solo son posibles si hemos convertido los datos a arrays.
la transpuesta de el escalar no le funciona porque no la convirtio previamente

escalar=np.array(5)
print(escalar.T)

Esto da como resultado 5 y es obvio si solo tenemos una fila y una columna.

Hola a todos, les comparto un listado de funciones en NumPy para trabajar con una array:

import numpy as np

a = np.array([
    [1, 3, 4, 5],
    [4, 7, 9, 1],
    [7, 8, 8, 2]
])
#========Function Basics===============
# print(np.sqrt(a))
# print(np.log(a))
# print(np.exp(a))
# print(np.sin(a))
# print(np.cos(a))
# print(np.tan(a))
# print(np.sum(a))
# ======================================
# print(np.min(a))
# print(np.max(a))
# ======================================
# print(np.mean(a))
# print(np.median(a))
# print(np.std(a))
# ======================================
# b = a.reshape(2,2,3)
# print(b)
# =====================================
# print(a.flatten())
#======================================
# print(a.flat[7])
#======================================
# for x in a.flat:
#     print(x)
#======================================
# print(a.transpose())

Hola compañeros les presento un código que hice para sumar dos matrices con el método “clásico” (sin usar NumPy) de complejidad O(n^2), con la función suma_matrices. Es muy fácil de entender. Espero les sirva.

def suma_matrices(matrixA, matrixB):
    # Inicializamos una matriz para mantener los resultados
    matrizSuma = []
    # Ciclo For para iterar a través de las filas de las matrices.
    for i in range(len(matrixA)):
        # Matriz fila para ir agregando la suma de cada elemento.
        fila = []
        # Ciclo For para iterar a través de las columnas de las matrices.
        for j in range(len(matrixA[0])):
            suma_ij = matrixA[i][j] + matrixB[i][j]
            fila.append(suma_ij)
        matrizSuma.append(fila)

    return matrizSuma


A = [[2, 5, 1],
     [6, 9, 7.4],
     [2, 1, 1],
     [8, 5, 3],
     [2, 1, 6],
     [5, 3, 1]]

B = [[7, 19, 5.1],
     [6.5, 9.2, 7.4],
     [2.8, 1.5, 12],
     [8, 5, 3],
     [2, 1, 6],
     [2, 33, 1]]

print(suma_matrices(A, B))

Cualquier duda o complemento me lo hacen saber. Gracias.

Si tenemos una matriz:

| a b c |
| d e f |
| g h i |

su transpuesta será:

| a d g |
| b e h |
| c f i |

Como las diagonales son iguales, al sumarlas se duplicarán

| 2*a   ?   ? |
| ?    2*e  ? |
| ?    ?  2*i |      

Si tomamos de referencia b, este ocupa el lugar de d en la transpuesta.

Por lo que al sumarlas, en una casilla quedará d + b y en la otra quedará b + d, que son iguales. Pasará lo mismo en el resto de pares que se intercambian la posición.

Al sumar una matriz con su transpuesta, se duplica la diagonal y nos queda una matriz perfectamente simétrica.

Por si a alguno le llamo la atención o no entendió lo que menciona en el minuto 5 aproximadamente el profesor , que la transpuesta nos ayuda a resolver sistemas de ecuaciones, y también en forma de pregunta si es posible dividir por una matriz como cuando resolvemos cuentas. Todo esto es de lo mas importante del curso y empieza desde el vídeo 11 en adelante. Todo lo visto hasta ahora y en un par de vídeos mas es preparatorio a dicho tema.

Transponer es cambiar las filas por columnas y se realiza con la función .T

La transpuesta de una matriz transpuesta dará lugar a la primera matriz

La suma de matrices tienen las mismas dimensiones

Reto superado, adjunto el código

Matriz_A = np.array([[1,2,3,4,5],[6,7,8,9,10],[11,12,13,14,15],[16,17,18,19,20],[21,22,23,24,25]])
Matriz_B = Matriz_A.T
Matriz_C = Matriz_A + Matriz_B

print(Matriz_A)
print(Matriz_B)
print(Matriz_C)

Transposición de una matriz:

• La transposición de una matriz es una operación que intercambia sus filas por columnas, es decir, las filas se convierten en columnas y las columnas se convierten en filas. En Python, podemos realizar la transposición de una matriz utilizando el atributo T.

import numpy as np

# Matriz original
A = np.array([[1, 2], [3, 4], [5, 6]])

# Transposición de la matriz A
A_transpuesta = A.T

print(A)
# resultado: [[1 2]
#             [3 4]
#             [5 6]]

print(A_transpuesta)
# resultado: [[1 3 5]
#             [2 4 6]]

Suma de matrices y escalares:

• La suma de matrices es una operación que se realiza elemento a elemento, es decir, para obtener el resultado de la suma de dos matrices, se suman los elementos correspondientes de ambas matrices. En el caso de la suma de un escalar y una matriz, el escalar se suma a cada uno de los elementos de la matriz. En Python, podemos realizar la suma de matrices y escalares utilizando el operador +.

import numpy as np

# Suma de matrices
A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])

C = A + B

print(C)
# resultado: [[ 6  8]
#             [10 12]]

# Suma de un escalar y una matriz
D = 2 * A + 3

print(D)
# resultado: [[ 5  7]
#             [ 9 11]]

Reto

d = np.array([[20,21,22],[23,24,25],[26,27,28]])
e = np.array([[29,30,31],[32,33,34],[35,36,37]])
f = d+e
print(f)

Comparto con ustedes otro código que realicé para calcular la transpuesta de una matriz de forma “clásica” sin usar NumPy. Espero les sirva.

# Función que extrae la columna de una matriz según la columna deseada.
def obtener_columna(matriz, numero_columna):
    # Inicializamos una matriz para mantener los resultados.
    columna = []
    # Ciclo For que recorre cada elemento de la columna.
    for i in range(len(matriz)):
        n = matriz[i][numero_columna]
        columna.append(n)
    return columna

# Función que calcula la transpuesta de una matriz.
def transpuesta(matriz):
    numero_columnas = len(matriz[0])
    # Inicializamos una matriz para mantener los resultados.
    matriz_transpuesta = []
    # Ciclo For que recorre cada columna y la devuelve como una fila.
    for i in range(numero_columnas):
        columna_Matriz = obtener_columna(matriz, i)
        # print(columna_Matriz)
        matriz_transpuesta.append(columna_Matriz)

    return matriz_transpuesta
  
m = [[5, 9, 11, 2],
     [3, 2, 99, 3],
     [7, 1,  8, 2]]

print(transpuesta(m))

matriz2 = np.array([[1,2,3,4,5],[3,4,6,7,8],[5,6,7,8,9,],[9,8,7,6,5],[11,12,13,14,15]])

​

​

print(matriz2)

​

[[ 1  2  3  4  5]
 [ 3  4  6  7  8]
 [ 5  6  7  8  9]
 [ 9  8  7  6  5]
 [11 12 13 14 15]]

matriz2_t = matriz2.T

print(matriz2_t)

[[ 1  3  5  9 11]
 [ 2  4  6  8 12]
 [ 3  6  7  7 13]
 [ 4  7  8  6 14]
 [ 5  8  9  5 15]]

reto = matriz2 + matriz2_t

print(reto)

[[ 2  5  8 13 16]
 [ 5  8 12 15 20]
 [ 8 12 14 15 22]
 [13 15 15 12 19]
 [16 20 22 19 30]]

Estas operaciones si que estan interesante. Sigo aprendiendo mas. Aui esta mi reto:
![](

![](

Transposición, suma de matrices y escalares

Transposición

Matemáticamente hablando, transponer significa cambiar las filas por columnas. Para escribir una transposición en Python, lo hacemos con la función **.T**.

# Esto NO es posible porque un escalar no tiene filas ni columnas
escalar_t = escalar.T 

# Esto nos devuelve lo mismo para el caso
vector_t = vector.T
print(vector_t)

# En este caso si que cambian las dimensiones de 3*2 a 2 * 3
matriz-t= matriz.T
print(matriz)

print(matriz.shape) # Output: (3, 2)
print(matriz_t.shape) # Output: (2, 3)

Para el caso de los tensores tenemos el mismo tipo de operación que para una matriz.

tenstor_t = tensor.T
print(tenstor_t)

Cuando transponemos la matriz transpuesta y la volvemos a transponer $(A^t)^t$ el resultado que obtenemos es la matriz original, o sea que $(A^t)^t = A$.

matriz_t_t = matriz_t.T
print(matriz_t_t) # obtenemos nuestra matriz original

Suma de matrices

La suma de matrices está definida, “matemáticamente” cuando los objetos tienen las mismas dimensiones.

# La suma de estas dos matrices es posible porque tienen las mismas dimensiones
matriz_1 = np.array([[56, 23], [45, 70]]) # (2, 2)
matriz_2 = np.array([[36, 88], [14, 26]]) # (2, 2)

# Las sumamos directamente
suma_matrices = matriz_1 + matriz_2

# imprimimos el resultado
print(suma_matrices) # Output = [[92 111] [59  96]]

De hecho podemos incluso sumar una matriz y un escalar siempre y cuando tengan las mismas dimensiones.

Ejercicio

matriz_5x5 = np.array([
  [56, 23, 17, 9, 35],
  [45, 70, 14, 28, 51],
  [62, 19, 8, 47, 12],
  [33, 55, 22, 39, 64],
  [10, 81, 73, 25, 41]
])

matriz_5x5_t = matriz_5x5.T

suma_matrices = matriz_5x5 + matriz_5x5_t

print("Matriz T", matriz_5x5_t)
print("Suma matrices",suma_matrices)

Comparto mis resultados del ejercicio

matriz5 = np.array([[1,2,3,4,5],[6,7,8,9,4],[5,11,13,14,6],[16,11,13,14,5],[11,12,1,5,8]])
matriz5_t = matriz5.T
print(matriz5 + matriz5_t)

los que no hicieron la ruta completa y se quejan de que no explica desde 0 el tema, les sugiero que sigan la ruta. ya vimos un millon de veces este tema desde distintos puntos de enseñanza.

• la suma de matrices esta definida matemáticamente cuando los objetos tienen el mismo tipo, las mismas dimensiones.

• Matemáticamente hablando transponer un vector o una matriz es cambiar las filas por columnas.

Transponer un vector

Teóricamente, es posible transponer un array de 1 dimensión, pero técnicamente, o más precisamente, en términos de lenguajes de programación, no es posible transponer un array de 1 dimensión.

# Reto
# Matriz de 5 x 5
matriz = np.array([[1,2,3,4,5], [6,7,8,9,10], [11,12,13,14,15], [16,17,18,19,20], [21,22,23,24,25]])
print("Ejemplo de una matriz de 5 x 5")
print(matriz)
transpuesta_matriz = matriz.T
print("Ejemplo de una matriz transpuesta de 5 x 5")
print(transpuesta_matriz)
suma_matriz_transpuesta_matriz = matriz + transpuesta_matriz
print("Ejemplo de la suma de una matriz y su transpuesta")
print(suma_matriz_transpuesta_matriz)

solución al reto:

import numpy as np
a= np.random.rand(5,5)
b= a.T
c= a+b

La funcion Random.Rand, nos realiza una array de numeros al azar cada vez que la ejecutemos.

![](

)

Challenge completed!

Elementos usados durante la clase:

escalar = 5.679
vector = np.array([1,2,3])
matriz = np.array([[1,2],[3,4],[5,6]])
tensor = np.array([
  [[1,2,3],[4,5,6],[7,8,9]],
  [[11,12,13],[14,15,16],[17,18,19]]
])

Para poder graficar un tensor, las dimensiones de cada una de las matrices que lo definen, es que al menos tengan 3 columnas

Aquí les dejo un ejemplo de como implementarlo con list comprehensions. Saludos!

array_3x2 = [[r + c for c in range(r+1, r + 3)] for r in range(3)]

rows = len(array_3x2)
columns = len(array_3x2[0])

array_2x3 = [[array_3x2[row][column] for row in range(rows)] for column in range(columns)]

print(f'Array 3x2: {array_3x2}')
print(f'Array 2x3: {array_2x3}')

_________________
Output:
Array 3x2: [[1, 2], [3, 4], [5, 6]]
Array 2x3: [[1, 3, 5], [2, 4, 6]]

#reto 
import numpy as np 
A=np.array([[1,2,3,4,5],[2,1,4,5,4],[1,3,1,4,5],[1,3,5,1,3],[1,2,4,3,4]]) 
B=A.T

print(A)
print("Traspuesta ")
print(B)

print("Suma")
print(A+B)

Sumar dos matrices de 5x5, donde una es la transpuesta de la otra.

import numpy as np


def run():
    A = np.array([ [1,2,3,4,5],
                   [1,2,3,4,5],
                   [1,2,3,4,5],
                   [1,2,3,4,5],
                   [1,2,3,4,5]
                ])

    A_t = A.T
    print(A)
    print('\n')
    print(A_t)
    suma = A + A_t
    print('\n')
    print(suma)

if __name__ == '__main__':
    run()

[[1 2 3 4 5]
 [1 2 3 4 5]
 [1 2 3 4 5]
 [1 2 3 4 5]
 [1 2 3 4 5]]


[[1 1 1 1 1]
 [2 2 2 2 2]
 [3 3 3 3 3]
 [4 4 4 4 4]
 [5 5 5 5 5]]


[[ 2  3  4  5  6]
 [ 3  4  5  6  7]
 [ 4  5  6  7  8]
 [ 5  6  7  8  9]
 [ 6  7  8  9 10]]

Se observa una diagonalización de los resultados, al hacer la suma de las matrices.

Ejemplo:

M = np.array([[1,2,3,4,5],[6,7,8,9,10],[11,12,13,14,15],[16,17,18,19,20],[21,22,23,24,25]])
M_t = M.T
print(M)
print(M_t)
print(M+M_t)

Buenas tardes, este es el codigo que realice para el reto de esta clase.

m_clase = np.array([[12, 11, 10, 8, 5],
                  [4, 5, 6, 2, 11],
                  [7, 8, 4, 2, 9],
                  [5, 5, 6, 7, 8],
                  [4, 8, 9, 7, 10]])
m_clase_t = m_clase.T
suma_m = m_clase + m_clase_t
print(suma_m)

Y este es el resultado que me dio
[[24 15 17 13 9]
[15 10 14 7 19]
[17 14 8 8 18]
[13 7 8 14 15]
[ 9 19 18 15 20]]

Así quedo mi código con el reto:

import numpy as np
matrizA = np.array([[1,2,3,4,5],[6,7,8,9,10],[11,12,13,14,15],[16,17,18,19,20],[21,22,23,24,25]])
matrizA_t= matrizA.T
matrizC= matrizA + matrizA_t
print (matrizC)

Y este fue el resultado:
[[ 2 8 14 20 26]
[ 8 14 20 26 32]
[14 20 26 32 38]
[20 26 32 38 44]
[26 32 38 44 50]]

Aquí mi ejercicio:

matrizt1 = np.array([[1,2,3,4,5],[2,3,4,5,6],[7,8,9,10,11],[12,13,14,15,16],[17,18,19,20,21]])
matrizt1_t = matrizt1.T
sumamatriz = matrizt1 + matrizt1_t
print(sumamatriz)

Les dejo mi reto resuelto:

matriz5x5=np.array([[1,1,1,1,1],[2,2,2,2, 2],[3,3,3,3,3],[4,4,4,4,4],[5,5,5,5,5]])
print(matriz5x5)

 #[[1 1 1 1 1]
 #[2 2 2 2 2]
 #[3 3 3 3 3]
 #[4 4 4 4 4]
 #[5 5 5 5 5]]

matriz5x5_t=matriz5x5.T
print(matriz5x5_t)
#[[1 2 3 4 5]
 #[1 2 3 4 5]
 #[1 2 3 4 5]
 #[1 2 3 4 5]
 #[1 2 3 4 5]]

matricesSumadas=matriz5x5+matriz5x5_t
print(matricesSumadas)

Resultado:

[[ 2  3  4  5  6]
 [ 3  4  5  6  7]
 [ 4  5  6  7  8]
 [ 5  6  7  8  9]
 [ 6  7  8  9 10]]

Trasposición y sumatoria de matrices

matriz A - original 
[[ 2  4  6  8  7]
 [ 4  1  0 10 12]
 [ 6 13 33 98  1]
 [ 6 17 45 33 28]
 [78 17 45  9 28]]

matriz B - transpuesta
[[ 2 4 6 6 78]
[ 4 1 13 17 17]
[ 6 0 33 45 45]
[ 8 10 98 33 9]
[ 7 12 1 28 28]]

matriz A + C - Suma de matrices
[[ 4 8 12 14 85]
[ 8 2 13 27 29]
[ 12 13 66 143 46]
[ 14 27 143 66 37]
[ 85 29 46 37 56]]

MM = np.array([
               [[1,2,3,4,5],[1,2,3,4,5],[1,2,3,4,5],[1,2,3,4,5],[1,2,3,4,5]],
               [[2,3,4,5,6],[2,3,4,5,6],[2,3,4,5,6],[2,3,4,5,6],[2,3,4,5,6]],
               [[3,4,5,6,7],[3,4,5,6,7],[3,4,5,6,7],[3,4,5,6,7],[3,4,5,6,7]],
               [[4,5,6,7,8],[4,5,6,7,8],[4,5,6,7,8],[4,5,6,7,8],[4,5,6,7,8]],
               [[5,6,7,8,9],[5,6,7,8,9],[5,6,7,8,9],[5,6,7,8,9],[5,6,7,8,9]]
])

MM_t = MM.T

suma_matriz = MM + MM_t

print(suma_matriz)


[[[ 2  4  6  8 30]
  [ 2  4  6  8 10]
  [ 2  4  6  8 10]
  [ 2  4  6  8 10]
  [ 2  4  6  8 10]]

 [[ 4  6  8 10 12]
  [ 4  6  8 10 12]
  [ 4  6  8 10 12]
  [ 4  6  8 10 12]
  [ 4  6  8 10 12]]

 [[ 6  8 10 12 14]
  [ 6  8 10 12 14]
  [ 6  8 10 12 14]
  [ 6  8 10 12 14]
  [ 6  8 10 12 14]]

 [[ 8 10 12 14 16]
  [ 8 10 12 14 16]
  [ 8 10 12 14 16]
  [ 8 10 12 14 16]
  [ 8 10 12 14 16]]

 [[30 12 14 16 18]
  [10 12 14 16 18]
  [10 12 14 16 18]
  [10 12 14 16 18]
  [10 12 14 16 18]]]

Un pequeño dato es la muestra que nos da un tensor al graficarlo y su transpuesta:

tensor = np.array([
      [[53,206,253],[48,227,221],[65,250,191],[48,227,119]],
      [[53,206,253],[48,227,221],[65,250,191],[48,227,119]],
      [[53,206,253],[48,227,221],[65,250,191],[48,227,119]],
])
plt.imshow(tensor, interpolation='nearest')
plt.show()

tensor_t = tensor.T
plt.imshow(tensor_t, interpolation='nearest')
print(tensor_t)

plt.show()

Suma de matriz y su transpuesta
a = np.array([[1,2,3,4,5],[6,7,8,9,10],[11,12,13,14,15],[16,17,18,19,20],[21,22,23,24,25]])
a_transpuesta = a.T
print(a)
print(a_transpuesta)
print(a + a_transpuesta)

[[ 1 2 3 4 5]
[ 6 7 8 9 10]
[11 12 13 14 15]
[16 17 18 19 20]
[21 22 23 24 25]]
[[ 1 6 11 16 21]
[ 2 7 12 17 22]
[ 3 8 13 18 23]
[ 4 9 14 19 24]
[ 5 10 15 20 25]]
[[ 2 8 14 20 26]
[ 8 14 20 26 32]
[14 20 26 32 38]
[20 26 32 38 44]
[26 32 38 44 50]]

Suma de matrices 5x5

Matriz5 = np.arange(25).reshape(5,5)
Matriz5_T = Matriz5.T
Suma =Matriz5 + Matriz5_T
print(Matriz5)
print()
print(Matriz5_T)
print()
print(Suma)

[[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]
 [15 16 17 18 19]
 [20 21 22 23 24]]

[[ 0  5 10 15 20]
 [ 1  6 11 16 21]
 [ 2  7 12 17 22]
 [ 3  8 13 18 23]
 [ 4  9 14 19 24]]

[[ 0  6 12 18 24]
 [ 6 12 18 24 30]
 [12 18 24 30 36]
 [18 24 30 36 42]
 [24 30 36 42 48]]

Lei en uno de los comentarios que seria bastante bueno que se aprenda a hacer esto sin librerias, para desarrollar lógica, creo que puede ser de ayuda para comprender mejor estos temas aunque obviamente no es obligatorio.

Les comparto mis resutltados 😄

import copy as cp


def matrix_sum(matrix_1: list, matrix_2: list):
	new_matrix = cp.deepcopy(matrix_1)

	for i, file in enumerate(new_matrix):
		for j in range(len(file)):
			new_matrix[i][j] += matrix_2[i][j]

	return new_matrix


def scalar_matrix(matrix: list, scalar: int):
	new_matrix = cp.deepcopy(matrix)
	for i, file in enumerate(matrix):
		for j in range(len(file)):
			new_matrix[i][j] *= scalar

	return new_matrix


def transpose(matrix: list):
	dummy_matrix = cp.deepcopy(matrix)
	new_matrix = cp.deepcopy(matrix)

	for i, file in enumerate(new_matrix):
		for j in range(len(file)):
			new_matrix[i][j] = dummy_matrix[j][i]

	return new_matrix


def print_matrix(matrix: list):
	for file in matrix:
		print(file)


if __name__ == '__main__':
	mat_1 = [[1, 2], [4, 3]]
	mat_2 = [[3, 5], [2, 7]]
	print('Matrix 1:')
	print_matrix(mat_1)
	print('Matrix 2:')
	print_matrix(mat_2)
	print(f'Matrix sum:{matrix_sum(mat_1, mat_2)}\nMatrix Scalar 3:\n1.-{scalar_matrix(mat_1, 3)}')
	print(f'2.-{scalar_matrix(mat_2, 3)}')
	transpose_matrix = transpose(mat_1)
	transpose_matrix_2 = transpose(mat_2)
	print('Transpose 1')
	print_matrix(transpose_matrix)
	print('Transpose 2')
	print_matrix(transpose_matrix_2)

Para sumar una matriz por su transpuesta el número de columnas tiene que ser igual al de filas ( M = N)

M = np.array([[1, 2], [3, 4]])
M_t = M.T

sum_M = M + M_t
print(sum_M)

no sé si es el profe pero esta clase mas clara no puede estar.

Para poder entender mejor cómo funciona la traspuesta en un tensor propongo usar este código:

tensor_t = tensor.T
print(tensor, tensor.shape)
print('-'*20)
print(tensor_t, tensor_t.shape)

Van a notar que al momento de ejecutarlo, si observan las formas, es como si se voltearan. El tensor original tenía (3,3,4) y cambió a (4,3,3). En otras palabras ha cambiado de tener 3 matrices de 3 vectores con 4 elementos a tener 4 matrices de 3 vectores de 3 elementos. Lo mismo ocurre con la matriz, su shape es igualmente conmutado.

[[[ 1  2  3 30]
  [ 4  5  6 31]
  [ 7  8  9 32]]

 [[11 12 13 33]
  [14 15 16 34]
  [17 18 19 35]]

 [[21 22 23 36]
  [24 25 26 37]
  [27 28 29 38]]] (3, 3, 4)
--------------------
[[[ 1 11 21]
  [ 4 14 24]
  [ 7 17 27]]

 [[ 2 12 22]
  [ 5 15 25]
  [ 8 18 28]]

 [[ 3 13 23]
  [ 6 16 26]
  [ 9 19 29]]

 [[30 33 36]
  [31 34 37]
  [32 35 38]]] (4, 3, 3)

A = np.array([[1,2,3,4,5],[3,4,5,6,7],[5,6,7,8,9],[7,8,9,0,1],[9,0,1,2,3]])
B = A.T
C = A + B
C
array([[ 2,  5,  8, 11, 14],
       [ 5,  8, 11, 14,  7],
       [ 8, 11, 14, 17, 10],
       [11, 14, 17,  0,  3],
       [14,  7, 10,  3,  6]])

Eh…creo que logré lo que me propuse pero no entiendo completamente cómo.

matriz + matriz[::-1].T[::-1].T

diego = np.array([
    [[9,8,7],[6,5,4],[3,2,1]],
    [[1,2,3],[4,5,6],[7,8,9]],
    [[1,5,9],[3,5,7],[2,5,8]],
]) 
print(diego)
[[[9 8 7]
  [6 5 4]
  [3 2 1]]

 [[1 2 3]
  [4 5 6]
  [7 8 9]]

 [[1 5 9]
  [3 5 7]
  [2 5 8]]]
diego_t = diego.T
print(diego_t)
[[[9 1 1]
  [6 4 3]
  [3 7 2]]

 [[8 2 5]
  [5 5 5]
  [2 8 5]]

 [[7 3 9]
  [4 6 7]
  [1 9 8]]]
print(diego+diego_t)
[[[18  9  8]
  [12  9  7]
  [ 6  9  3]]

 [[ 9  4  8]
  [ 9 10 11]
  [ 9 16 14]]

 [[ 8  8 18]
  [ 7 11 14]
  [ 3 14 16]]]```
Gracias🤔

matriz_ejemplo = np.array([[1,2,3,4,5],[11,12,13,14,15],[21,22,23,24,25],[31,32,33,34,35],[41,42,43,44,45]])
print(matriz_ejemplo)
[[ 1  2  3  4  5]
 [11 12 13 14 15]
 [21 22 23 24 25]
 [31 32 33 34 35]
 [41 42 43 44 45]]
matriz_ejemplo_t = matriz_ejemplo.T
c = a+b
a = matriz_ejemplo
b = matriz_ejemplo_t
c = a+b
c
print(c)
[[ 2 13 24 35 46]
 [13 24 35 46 57]
 [24 35 46 57 68]
 [35 46 57 68 79]
 [46 57 68 79 90]]

matriz_2 = np.array([
    [1,2,3,4,5],
    [5,4,3,2,1],
    [4,5,2,3,1],
    [2,3,1,4,5],
    [10,11,12,13,14],
])

matriz_2_t = matriz_2.T
[[ 1  5  4  2 10]
 [ 2  4  5  3 11]
 [ 3  3  2  1 12]
 [ 4  2  3  4 13]
 [ 5  1  1  5 14]]

sumaMatriz = matriz_2 + matriz_2_t
print(sumaMatriz)

[[ 2  7  7  6 15]
 [ 7  8  8  5 12]
 [ 7  8  4  4 13]
 [ 6  5  4  8 18]
 [15 12 13 18 28]]

matriz2 = np.array([[1,2,3,4,5],[3,4,6,7,8],[5,6,7,8,9,],[9,8,7,6,5],[11,12,13,14,15]])
matriz2_t = matriz2.T
print(matriz2+matriz2_t)
[[ 2  5  8 13 16]
 [ 5  8 12 15 20]
 [ 8 12 14 15 22]
 [13 15 15 12 19]
 [16 20 22 19 30]]```

Obtenemos una matriz simétrica.
si A es una matriz simétrica A=A.T

• La suma está definida en el caso en el que las matrices tengan las mismas dimensiones.

matriz = np.array([[1,2,3,4,5],[6,7,8,9,10],[11,12,13,14,15],[16,17,18,19,20],[21,22,23,24,25]])
matriz_t = matriz.T
matriz_add = matriz + matriz_t
print("matriz Original")
print(matriz)
print("\nmatriz Transpuesta")
print(matriz_t)
print("\nSuma de la matriz + matriz_t")
print(matriz_add)
matriz Original
[[ 1  2  3  4  5]
 [ 6  7  8  9 10]
 [11 12 13 14 15]
 [16 17 18 19 20]
 [21 22 23 24 25]]

matriz Transpuesta
[[ 1  6 11 16 21]
 [ 2  7 12 17 22]
 [ 3  8 13 18 23]
 [ 4  9 14 19 24]
 [ 5 10 15 20 25]]

Suma de la matriz + matriz_t
[[ 2  8 14 20 26]
 [ 8 14 20 26 32]
 [14 20 26 32 38]
 [20 26 32 38 44]
 [26 32 38 44 50]]```

matriz = np.array([[7,6,3,7,5],[7,2,5,0,5],[3,3,4,6,0],[9,0,6,7,7],[8,2,0,1,2]])
print(matriz)
[[7 6 3 7 5]
 [7 2 5 0 5]
 [3 3 4 6 0]
 [9 0 6 7 7]
 [8 2 0 1 2]]

matriz_t=matriz.T
print(matriz_t)
[[7 7 3 9 8]
 [6 2 3 0 2]
 [3 5 4 6 0]
 [7 0 6 7 1]
 [5 5 0 7 2]]

print(matriz+matriz_t)
[[14 13  6 16 13]
 [13  4  8  0  7]
 [ 6  8  8 12  0]
 [16  0 12 14  8]
 [13  7  0  8  4]]

Ejercicio:

EJERCICIO:
![](

Ejercicio:

5,5
e = np.ones([5,5])
print(e)
result = e + e.T
print(result)
[[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.]]
[[2. 2. 2. 2. 2.]
 [2. 2. 2. 2. 2.]
 [2. 2. 2. 2. 2.]
 [2. 2. 2. 2. 2.]
 [2. 2. 2. 2. 2.]]

import numpy as np
matriz = np.array([
                   [1, 2, 3, 4, 5], 
                   [1, 2, 3, 4, 5],
                   [1, 2, 3, 4, 5],
                   [1, 2, 3, 4, 5],
                   [1, 2, 3, 4, 5],
                   ])
matriz_t = matriz.T
c = matriz + matriz_t
print(matriz)
print(matriz_t)
print(c)

Aca una forma mas facil de crear matrices, a partir de otra.

matriz = np.array([[1, 2], [4,5], [ 8, 9]])

M_A = matriz * 2
M_B = matriz * 3

M_C = M_A + M_B

print(M_A, M_B, M_C)

A = np.array([[1,2,3,4,5],[1,2,3,4,5],[6,7,8,9,10],[6,7,8,9,10],[1,2,3,4,5]])
A_t = A.T
print('Matriz A:')
print(A)
print('Matriz A_t')
print(A_t)
print('Suma de A + A_T: ')
print(A + A_t)

resultado:
Matriz A:
[[ 1  2  3  4  5]
 [ 1  2  3  4  5]
 [ 6  7  8  9 10]
 [ 6  7  8  9 10]
 [ 1  2  3  4  5]]

Matriz A_t
[[ 1  1  6  6  1]
 [ 2  2  7  7  2]
 [ 3  3  8  8  3]
 [ 4  4  9  9  4]
 [ 5  5 10 10  5]]

Suma de A + A_T: 
[[ 2  3  9 10  6]
 [ 3  4 10 11  7]
 [ 9 10 16 17 13]
 [10 11 17 18 14]
 [ 6  7 13 14 10]]


Una disculpa, no supe como adjuntar una imagen

Aunque no sea necesario si quieren tener los mismos vectores, matrices y tensores:

<code>
e = 5.679
vector = np.array([3,4,5,6])
matriz = np.array([[1,2], [3,4], [5,6]])
tensor = np.array([
    [[1,2,3,30], [4,5,6,31], [7,8,9,32]],
    [[11,12,13,33], [14,15,16,34], [17,18,19,35]],
    [[21,22,23,36], [24,25,26,37], [27,28,29,38]],
])

Resultado del ejercicio:

• Generación de matriz de 5x5 con números aleatorios
• Calculo de la transpuesta
• Suma de la matriz original y la transpuesta
  
  

# Creacion de la matriz vacia 
matriz_vacia =[]
a=matriz.shape[0]
b= matriz.shape[1]
i=0
while(i<a):
    matriz_vacia.append([0])
    j=1
    while(j<b):
        matriz_vacia[i].append(0)
        j= j +1
    i= i+1

#Suma de escalar
i=0
while(i<a):
    j=0
    while(j<b):
        matriz_vacia[i][j] = escalar + matriz[i][j]
        j = j+1
    i = i+1

matriz_vacia```

escalar = 5.678
vector = np.array([3,4,5,6])
matriz = np.array([[1,2],[3,4],[5,6]])
tensor = np.array([
[[1,2,3,30],[4,5,6,31],[7,8,9,32]],
[[11,12,13,33],[14,15,16,34],[17,18,19,35]],
[[21,22,23,36],[24,25,26,37],[27,28,29,38]],
])

Transposición, suma de matrices y escalares

• Para realizar la transpuesta tanto, de un vector como de una matriz o un tensor utilizamos el motodo .T.
• Si lo que queremos es realizar una suma de matrices (IMPORTANTE deben ser si o si de las misma diemensiones) simplemente colocamos “+” entre ambas como si estuviesemos sumando numeros. Lo mismo se puede hacer con los tensores pero cada una de las matrices que contenga deben ser de misma dimensiones.
• Tambien podemos sumar un escalar a una matriz o un tensor y una matriz a un tensor.

Cumpliendo el reto:

A = np.array([[1,2,3,4,5],
              [1,2,3,4,5],
              [1,2,3,4,5],
              [1,2,3,4,5],
              [1,2,3,4,5]])
A_t = A.T
C = A + A_t 
print(C)
[[ 2  3  4  5  6]
 [ 3  4  5  6  7]
 [ 4  5  6  7  8]
 [ 5  6  7  8  9]
 [ 6  7  8  9 10]]

Les dejo también mis apuntes de la clase en cuanto a numpy 😄

Transponer una matriz, es cambiar la posición de las filas por columnas, los elementos en ij pasan a estar en ji.

Para transponer en nump, utilizamos únicamente la función nparray.T

La suma de matrices en numpyu se hace mediante el operador + siempre y cuando ambas matrices cuenten con el mismo numero de filas y de columnas

new_matrix = matrix + matrix_2

En numpy también podemos sumarle un escalar a cada elemento de nuestra matriz, haciendo simplemente la suma del escalar por la matriz

new_matrix = matrix + scalar

Por ultimo para un escalar, funciona igual que con la suma, únicamente multiplicamos nuestra matriz por el escalar deseado

scalar_matrix = matrix * 4

Para que nos sirve transponer una matriz?

• Nos ayuda a despejar una de las incógnitas cuando tenemos un sistema de ecuaciones.

Transponer un vector o una matriz es cambiar filas por columnas, si tengo un vector y se transpongo lo que obtengo es una columna, si tengo una matriz por ejemplo de 3 x 2 lo que obtengo es una matriz de 2 x 3, donde los elementos que estaban en la diagonal se mantienen en la diagonal y cambia de arriba abajo todos los que estaban en los otros lugares.

matrizA = np.array([[1,2,3,4,5],[44,31,47,20,25],[7,9,5,1,3],[99,87,6,4,32],[64,9,6,48,7]])

matrizR = matrizA + matrizA.T
print(matrizR)

[[  2  46  10 103  69]
 [ 46  62  56 107  34]
 [ 10  56  10   7   9]
 [103 107   7   8  80]
 [ 69  34   9  80  14]]

Si deseas manipular los elementos de una matriz con **NumPy **te comparto esto:

import numpy as np
#======Other Arrays for Join===========

c = np.array([
    [1,2,3,7],
    [4,5,6,7],
    [7,8,9,7]
])

d = np.array([
    [10,20,30,40],
    [50,60,70,80],
    [70,80,10,20]
])
#========Joining Arrays=========
# e = np.concatenate((c,d))
# print(e)
# print(e.shape)
#=======================================
# e2 = np.stack((c,d))
# print(e2)
# print(e2.shape)
#=======================================
# e2 = np.hstack((c,d))
# print(e2)
#=======================================
# e2 = np.vstack((c,d))
# print(e2)
#========Splitting Arrays===============

f = np.array([
    [1,2,3,4,5,5],
    [4,5,6,7,8,6],
    [3,9,2,5,8,2],
    [8,9,2,3,1,7],
])

#=======================================
# print(np.split(f,4))
# print(np.split(f,2))
#======================================
# print(np.hsplit(f,3))
#=======================================
# print(np.vsplit(f,2))
#=======================================


#=Adding Values or Adding List into array=

g = np.array([
    [1,2,3,4],
    [4,5,6,7],
    [7,8,9,5],
    [9,8,7,1]
])

h = [10,20,30,40]
#=======================================
# i = np.append(g, h)
# print(i)
#=======================================
# i = np.append(g, [h], axis=0)
# print(i)
#=======================================
# i = np.insert(g,2,h,axis=0)
# print(i)
#=======================================
# i = np.insert(g,2,h,axis=1)
# print(i)

Matriz Original:
matCin = np.array([[7,8,9,7,8],[7,4,8,5,7],[9,7,8,9,5],[7,9,8,4,5],[8,7,9,1,2]])
Producto de la operación de la original con la traspuesta:
[[14 15 18 14 16]
[15 8 15 14 14]
[18 15 16 17 14]
[14 14 17 8 6]
[16 14 14 6 4]]