Python Matrice: Exemple de transpunere, multiplicare, matrice NumPy

Ce Este Python Matrice?

A Python matricea este o matrice dreptunghiulară bidimensională specializată de date stocate în rânduri și coloane. Datele dintr-o matrice pot fi numere, șiruri de caractere, expresii, simboluri etc. Matricea este una dintre structurile de date importante care pot fi utilizate în calcule matematice și științifice.

Cum Python Matricele funcționează?

Datele din interiorul matricei bidimensionale în format matrice arată după cum urmează:

Pas 1) Arată o matrice 2×2. Are două rânduri și 2 coloane. Datele din interiorul matricei sunt numere. Rândul1 are valorile 2,3, iar rândul2 are valorile 4,5. Coloanele, adică col1, au valorile 2,4, iar col2 are valorile 3,5.

Pas 2) Arată o matrice 2×3. Are două rânduri și trei coloane. Datele din primul rând, adică rândul1, au valorile 2,3,4, iar rândul2 are valorile 5,6,7. Coloanele col1 are valorile 2,5, col2 are valorile 3,6 și col3 are valorile 4,7.

Deci, în mod similar, puteți avea datele stocate în matricea nxn PythonO mulțime de operații pot fi efectuate pe o adunare de tip matrice, subtracțiune, înmulțire etc.

Python nu are o modalitate simplă de a implementa un tip de date matrice.

Matricea Python folosește matrice și același lucru poate fi implementat.

• Crearea unei Python Matrice folosind tipul de date din listă imbricată
• Crează Python Matrice folosind Arrays from Python Pachet Numpy

Crează Python Matrice folosind un tip de date cu listă imbricată

In Python, tablourile sunt reprezentate folosind tipul de date listă. Deci acum vom folosi lista pentru a crea o matrice python.

Vom crea o matrice 3×3, după cum se arată mai jos:

• Matricea are 3 rânduri și 3 coloane.
• Primul rând într-un format de listă va fi după cum urmează: [8,14,-6]
• Al doilea rând dintr-o listă va fi: [12,7,4]
• Al treilea rând dintr-o listă va fi: [-11,3,21]

Matricea din interiorul unei liste cu toate rândurile și coloanele este așa cum se arată mai jos:

List = [[Row1], 
           [Row2], 
           [Row3]
           ...
           [RowN]]

Deci, conform matricei enumerate mai sus, tipul de listă cu datele matricei este după cum urmează:

M1 = [[8, 14, -6], [12,7,4], [-11,3,21]]

Pentru a citi datele din interior Python Matrice folosind o listă.

Vom folosi matricea definită mai sus. Exemplul va citi datele, va imprima matricea, va afișa ultimul element din fiecare rând.

Exemplu: Pentru a imprima matricea

M1 = [[8, 14, -6], 
           [12,7,4], 
           [-11,3,21]]

#To print the matrix
print(M1)

ieșire:

The Matrix M1 =  [[8, 14, -6], [12, 7, 4], [-11, 3, 21]]

Exemplul 2: Pentru a citi ultimul element din fiecare rând

M1 = [[8, 14, -6],
           [12,7,4], 
           [-11,3,21]]

matrix_length = len(M1)

#To read the last element from each row.
for i in range(matrix_length):
    print(M1[i][-1])

ieșire:

-6
4
21

Exemplul 3: Pentru a imprima rândurile din Matrice

M1 = [[8, 14, -6],
           [12,7,4], 
           [-11,3,21]]

matrix_length = len(M1)

#To print the rows in the Matrix
for i in range(matrix_length):
    print(M1[i])

ieșire:

[8, 14, -6]
[12, 7, 4]
[-11, 3, 21]

Adăugarea de matrici utilizând lista imbricată

Putem adăuga cu ușurință două matrici date. Matricele de aici vor fi sub formă de listă. Să lucrăm la un exemplu care va avea grijă să adăugăm matricele date.

Matricea 1:

M1 = [[8, 14, -6],
           [12,7,4], 
           [-11,3,21]]

Matricea 2:

M2 = [[3, 16, -6],
           [9,7,-4], 
           [-1,3,13]]

Last va inițializa o matrice care va stoca rezultatul M1 + M2.

Matricea 3:

M3  = [[0,0,0],
            [0,0,0],
            [0,0,0]]

Exemplu: Adăugarea de matrici

Pentru a adăuga, matricele vor folosi o buclă for care va trece prin ambele matrice date.

M1 = [[8, 14, -6], 
      [12,7,4], 
      [-11,3,21]]

M2 = [[3, 16, -6],
           [9,7,-4], 
           [-1,3,13]]

M3  = [[0,0,0],
       [0,0,0],
       [0,0,0]]
matrix_length = len(M1)

#To Add M1 and M2 matrices
for i in range(len(M1)):
for k in range(len(M2)):
        M3[i][k] = M1[i][k] + M2[i][k]

#To Print the matrix
print("The sum of Matrix M1 and M2 = ", M3)

ieșire:

The sum of Matrix M1 and M2 =  [[11, 30, -12], [21, 14, 0], [-12, 6, 34]]

Înmulțirea matricelor folosind Lista imbricată

Pentru a multiplica matricele, putem folosi bucla for pe ambele matrice, așa cum se arată în codul de mai jos:

M1 = [[8, 14, -6], 
      [12,7,4], 
      [-11,3,21]]

M2 = [[3, 16, -6],
           [9,7,-4], 
           [-1,3,13]]

M3  = [[0,0,0],
       [0,0,0],
       [0,0,0]]

matrix_length = len(M1)

#To Multiply M1 and M2 matrices
for i in range(len(M1)):
for k in range(len(M2)):
        M3[i][k] = M1[i][k] * M2[i][k]

#To Print the matrix
print("The multiplication of Matrix M1 and M2 = ", M3)

ieșire:

The multiplication of Matrix M1 and M2 =  [[24, 224, 36], [108, 49, -16], [11, 9, 273]]

Crează Python Matrice folosind Arrays from Python Pachet Numpy

Biblioteca python Numpy ajută la tratarea matricelor. Numpy procesează o matrice puțin mai rapid în comparație cu lista.

Pentru a lucra cu Numpy, trebuie să îl instalați mai întâi. Urmați pașii de mai jos pentru a instala Numpy.

Pas 1) Comanda pentru a instala Numpy este:

pip install NumPy

Pas 2) Pentru a utiliza Numpy în codul dvs., trebuie să îl importați.

import NumPy

Pas 3) De asemenea, puteți importa Numpy folosind un alias, așa cum se arată mai jos:

import NumPy as np

Vom folosi metoda array() de la Numpy pentru a crea o matrice python.

Exemplu: Matrice în Numpy de creat Python Matrice

import numpy as np
M1 = np.array([[5, -10, 15], [3, -6, 9], [-4, 8, 12]])
print(M1)

ieșire:

[[  5 -10  15]
 [  3  -6   9]
 [ -4   8  12]]

Matrice Operaține folosind Numpy.Array()

Operația cu matricea care poate fi efectuată este adunarea, subducțiuneatracțiune, înmulțire, transpunere, citirea rândurilor, coloanelor unei matrice, felierea matricei etc. În toate exemplele, vom folosi o metodă array().

Adăugarea matricei

Pentru a efectua adăugarea pe matrice, vom crea două matrice folosind numpy.array() și le vom adăuga folosind operatorul (+).

Exemplu:

import numpy as np

M1 = np.array([[3, 6, 9], [5, -10, 15], [-7, 14, 21]])
M2 = np.array([[9, -18, 27], [11, 22, 33], [13, -26, 39]])
M3 = M1 + M2  
print(M3)

ieșire:

[[ 12 -12  36]
 [ 16  12  48]
 [  6 -12  60]]

Matrix SubtracTION

Pentru a efectua subtracțiune pe matrice, vom crea două matrici folosind numpy.array() și subtracfolosind operatorul (-).

Exemplu:

import numpy as np

M1 = np.array([[3, 6, 9], [5, -10, 15], [-7, 14, 21]])
M2 = np.array([[9, -18, 27], [11, 22, 33], [13, -26, 39]])
M3 = M1 - M2  
print(M3)

ieșire:

[[ -6  24 -18]
 [ -6 -32 -18]
 [-20  40 -18]]

Înmulțirea matriceală

Mai întâi se vor crea două matrici folosind numpy.arary(). Pentru a le multiplica voința, puteți folosi metoda numpy dot(). Numpy.dot() este produsul scalar al matricei M1 și M2. Numpy.dot() gestionează tablourile 2D și efectuează înmulțiri de matrice.

Exemplu:

import numpy as np

M1 = np.array([[3, 6], [5, -10]])
M2 = np.array([[9, -18], [11, 22]])
M3 = M1.dot(M2)  
print(M3)

ieșire:

[[  93   78]
 [ -65 -310]]

Transpunerea matricei

Se calculează transpunerea unei matrice, prin schimbarea rândurilor ca coloane și coloanelor ca rânduri. Funcția transpose() din Numpy poate fi utilizată pentru a calcula transpunerea unei matrice.

Exemplu:

import numpy as np

M1 = np.array([[3, 6, 9], [5, -10, 15], [4,8,12]])
M2 = M1.transpose()

print(M2)

ieșire:

[[  3   5   4]
 [  6 -10   8]
 [  9  15  12]]

Tăierea unei matrice

Tăierea vă va returna elementele din matrice pe baza indexului de început / sfârșit dat.

• Sintaxa pentru feliere este – [start:end]
• Dacă indicele de început nu este dat, acesta este considerat 0. De exemplu [:5], înseamnă ca [0:5].
• Dacă sfârșitul nu este trecut, acesta va lua ca lungime a matricei.
• Dacă începutul/sfârșitul are valori negative, tăierea se va face de la sfârșitul matricei.

Înainte de a lucra la slice pe o matrice, să înțelegem mai întâi cum să aplicăm slice pe o matrice simplă.

import numpy as np

arr = np.array([2,4,6,8,10,12,14,16])
print(arr[3:6]) # will print the elements from 3 to 5
print(arr[:5]) # will print the elements from 0 to 4
print(arr[2:]) # will print the elements from 2 to length of the array.
print(arr[-5:-1]) # will print from the end i.e. -5 to -2
print(arr[:-1]) # will print from end i.e. 0 to -2

ieșire:

[ 8 10 12]
[ 2  4  6  8 10]
[ 6  8 10 12 14 16]
[ 8 10 12 14]
[ 2  4  6  8 10 12 14]

Acum să implementăm felierea pe matrice. Pentru a efectua tăierea pe o matrice

sintaxa va fi M1[row_start:row_end, col_start:col_end]

• Primul început/sfârșit va fi pentru rând, adică pentru a selecta rândurile matricei.
• Al doilea început/sfârșit va fi pentru coloană, adică pentru a selecta coloanele matricei.

Matricea M1 pe care o vom folosi este următoarea:

M1 = np.array([[2, 4, 6, 8, 10], 
    [3, 6, 9, -12, -15],
    [4, 8, 12, 16, -20],
    [5, -10, 15, -20, 25]])

Sunt în total 4 rânduri. Indicele începe de la 0 la 3. 0^th rândul este [2,4,6,8,10], 1^st rândul este [3,6,9,-12,-15] urmat de 2^nd și 3^rd.

Matricea M1 are 5 coloane. Indicele începe de la 0 la 4. 0^th coloana are valorile [2,3,4,5], 1^st coloanele au valorile [4,6,8,-10] urmate de 2^nd, 3^rd, 4^th, și 5^th.

Iată un exemplu care arată cum să obțineți datele de rânduri și coloane din matrice folosind tăierea. În exemplu, tipărim 1^st și 2^nd rând, iar pentru coloane, dorim prima, a doua și a treia coloană. Pentru a obține acea ieșire am folosit: M1[1:3, 1:4]

Exemplu:

import numpy as np

M1 = np.array([[2, 4, 6, 8, 10], 
    [3, 6, 9, -12, -15],
    [4, 8, 12, 16, -20],
    [5, -10, 15, -20, 25]])
print(M1[1:3, 1:4]) # For 1:3, it will give first and second row.
#The columns will be taken from first to third.

ieșire:

[[  6   9 -12]
 [  8  12  16]]

Exemplu: pentru a tipări toate rândurile și a treia coloană

import numpy as np
M1 = np.array([[2, 4, 6, 8, 10], 
    [3, 6, 9, -12, -15],
    [4, 8, 12, 16, -20],
    [5, -10, 15, -20, 25]])
print(M1[:,3]) # This will print all rows and the third column data.

ieșire:

[  8 -12  16 -20]

Exemplu: pentru a imprima primul rând și toate coloanele

import numpy as np

M1 = np.array([[2, 4, 6, 8, 10], 
    [3, 6, 9, -12, -15],
    [4, 8, 12, 16, -20],
    [5, -10, 15, -20, 25]])
print(M1[:1,]) # This will print first row and all columns

ieșire:

[[ 2  4  6  8 10]]

Exemplu: pentru a tipări primele trei rânduri și primele 2 coloane

import numpy as np

M1 = np.array([[2, 4, 6, 8, 10], 
    [3, 6, 9, -12, -15],
    [4, 8, 12, 16, -20],
    [5, -10, 15, -20, 25]])
print(M1[:3,:2])

ieșire:

[[2 4]
 [3 6]
 [4 8]]

Accesarea NumPy Matrix

Am văzut cum funcționează tăierea. Luând în considerare acest lucru, vom vedea cum să obținem rândurile și coloanele din matrice.

Pentru a imprima rândurile matricei

În exemplu se vor imprima rândurile matricei.

Exemplu:

import numpy as np
M1 = np.array([[3, 6, 9], [5, -10, 15], [4,8,12]])
print(M1[0])  #first row
print(M1[1]) # the second row
print(M1[-1]) # -1 will print the last row

ieșire:

[3 6 9]
[  5 -10  15]
[ 4  8 12]

Pentru a obține ultimul rând, puteți folosi indexul sau -1. De exemplu, matricea are 3 rânduri,

deci M1[0] vă va oferi primul rând,

M1[1] vă va oferi al doilea rând

M1[2] sau M1[-1] vă va oferi al treilea rând sau ultimul rând.

Pentru a imprima coloanele matricei

import numpy as np
M1 = np.array([[2, 4, 6, 8, 10], 
    [3, 6, 9, -12, -15],
    [4, 8, 12, 16, -20],
    [5, -10, 15, -20, 25]])
print(M1[:,0]) # Will print the first Column
print(M1[:,3]) # Will  print the third Column
print(M1[:,-1]) # -1 will give you the last column

ieșire:

[2 3 4 5]
[  8 -12  16 -20]
[ 10 -15 -20  25]

Rezumat

• A Python matricea este o matrice dreptunghiulară bidimensională specializată de date stocate în rânduri și coloane. Datele dintr-o matrice pot fi numere, șiruri de caractere, expresii, simboluri etc. Matricea este una dintre structurile de date importante care pot fi utilizate în calcule matematice și științifice.
• Python nu are o modalitate simplă de a implementa un tip de date matrice. Python matricea poate fi creată folosind un tip de date cu listă imbricată și folosind biblioteca numpy.
• Biblioteca python Numpy ajută la tratarea matricelor. Numpy procesează o matrice puțin mai rapid în comparație cu lista.
• Operația cu matricea care poate fi efectuată este adunarea, subducțiuneatracțiune, înmulțire, transpunere, citirea rândurilor, coloanelor unei matrice, felierea matricei etc.
• Pentru a adăuga două matrice, puteți folosi numpy.array() și le puteți adăuga folosind operatorul (+).
• Pentru a le multiplica will, puteți folosi metoda numpy dot(). Numpy.dot() este produsul scalar al matricei M1 și M2. Numpy.dot() gestionează tablourile 2D și efectuează înmulțiri de matrice.
• Transpunerea unei matrice se calculează prin schimbarea rândurilor ca coloane și coloanelor ca rânduri. Funcția transpose() din Numpy poate fi utilizată pentru a calcula transpunerea unei matrice.
• Tăierea unei matrice vă va returna elementele pe baza indexului de început / sfârșit dat.

Acest cod este editabil. Faceți clic pe Run to Execute