Come calcolare le matrici in Python senza numpy
Una matrice può contenere stringhe, numeri e altri tipi di dati. In una matrice, i dati sono impilati in entrambe le colonne e le righe. Una struttura di dati chiave a supporto dei calcoli in scienza e matematica è la matrice. Poiché Python non fornisce un tipo incorporato per un oggetto Matrix, trattiamo elenchi tra elenchi o addirittura un elenco nidificato come matrice.
Come le matrici in Python lavorano
I dati sono scritti in un array bidimensionale per generare una matrice. La procedura è la seguente:
[[1 3 5 7 9][2 4 6 8 10]
[0 8 7 4]]
Ha una matrice da 3 per 5 come display. Quindi, le sue dimensioni sono 3 per 5. I dati all'interno di questa matrice sono costituiti da oggetti di intero del tipo di dati. La riga superiore, riga1, ha i valori 1, 3, 5, 7 e 9, mentre la riga2, insieme a riga3, ha i valori (2, 4, 6, 8) e rispettivamente (0, 8, 7, 4). Column1 contiene valori di (1, 2, 0) e colonna2 ha valori di (3, 4, 8) e così via.
Python ci consente di archiviare tutti i dati in una matrice con due dimensioni. Possiamo aggiungere matrici, moltiplicarle, trasgimi ed eseguire altre operazioni su una matrice. Utilizzando array, possiamo costruire una matrice Python e usarla in modo simile. Parliamo di diversi esempi di matrici di pitone.
Python Matrix Aggiunta
Prenderemo le due matrici e le aggiungeremo per iterare attraverso di loro usando un ciclo nidificato.
Matrix1 = [[2, 4, 1],[4, 1, 5],
[3, 6, 7]]
Matrix2 = [[4, 2, -1],
[5, 6, -3],
[0, -4, 3]]
Matrix3 = [[0,1,0],
[1,0,0],
[0,0,1]]
Matrix4 = [[0,0,1],
[0,1,0],
[1,0,0]]
Matrices_Length = len (Matrix1)
per riga nell'intervallo (len (matrix1)):
per colonna nell'intervallo (len (matrix2 [0]):
Matrix4 [riga] [colonna] = Matrix1 [riga] [colonna] + matrix2 [row] [colonna] + matrix3 [riga] [colonna]
print ("La somma delle matrici è =", Matrix4)
Inizialmente, piuttosto che usare Numpy, abbiamo costruito direttamente tre matrici con ordine 3 per 3. Abbiamo specificato l'ordine o la lunghezza della matrice 1 come funzione Len () e altri, rispettivamente. Usando i loop nidificati, in primo luogo, sono state aggiunte le tre matrici. Il totale delle tre matrici è stato quindi specificato come matrice 4 e abbiamo usato la funzione print () per visualizzare i risultati.
Trasponi una matrice in Python
Scambiando gli elementi delle colonne e delle righe della matrice, potremmo trasporli. Usando esempi diversi, dimostreremo come ottenere una trasposizione di una matrice usando Python senza numpy.
La trasposizione di una matrice è rappresentata dal simbolo a. Ad esempio, supponiamo che abbiamo una matrice "A" con l'ordine di:
3 per 2
Quindi la trasposizione di A è:
Matrix 2 per 3
Calcolo della trasposizione di una matrice con l'aiuto di un ciclo nidificato
Il ciclo nidificato può essere usato per ripetutamente iterazione attraverso le colonne e le file anche di un elenco nidificato. Inserire l'elemento nella riga "ith" e la colonna "jth" di matrice F insieme alla riga "jth" e "ith" colonna di matrice "f^t" per ottenere la trasposizione della matrice. "F^T" sarà una matrice 2 per 3 che assume che "F" sia una matrice 3 per 2.
F = [[2, 3],[5, 7],
[8, 1]]
F_t = [[0, 0, 0],
[0, 0, 0]]
per q in gamma (len (f)):
per w in gamma (len (f [0])):
F_t [w] [q] = f [q] [w]
per q in f_t:
Stampa (Q)
Viene creata una matrice trasposa della matrice originale e una matrice "F" con un ordine 3 per 2. Il programma precedente utilizza i loop "per" nidificati, continuamente iterali su ogni riga e successivamente ogni colonna. Ad ogni iterazione, aggiungiamo un elemento da "F [Q] [W]" in "ft [w] [q]". Infine, eseguiamo il metodo Print () per rappresentare la trasposizione.
Utilizzando una comprensione dell'elenco nidificato per trovare la trasposizione della matrice
Viene prodotto un elenco nidificato quando viene eseguita una comprensione dell'elenco all'interno di un altro elenco di comprensione. Di seguito è la sintassi per la comprensione degli elenchi nidificati:
new_list = [[expr. per un elemento elenco] per un elemento dell'elenco]Allo stesso modo, potremmo ottenere la trasposizione di una matrice usando la comprensione dell'elenco nidificato in un approccio a loop così nidificato.
J = [[1, 3],[4, 6],
[9, 2]]
J_t = [[j [v] [c] per v nell'intervallo (len (j))] per c nell'intervallo (len (j [0]))]
per c in j_t:
stampa (c)
Iniziamo creando Matrix "J", avendo l'ordine 3 per 2. La comprensione della lista nidificata nel codice che precede i loop sui membri della matrice una volta alla volta e inserisce gli elementi di "j [v]" da qualche parte nella posizione "j_t [v]". Le colonne della matrice sono iterate in tutta la prima parte di tale comprensione della lista nidificata, mentre le sue righe vengono ripetute nella seconda colonna.
Moltiplicazione di due matrici in Python
Il processo binario di matrici multiplicazioni crea la matrice usando due matrici. Utilizzando i loop nidificati e la comprensione dell'elenco, possiamo moltiplicare le matrici in Python.
La colonna della prima matrice e il conteggio della seconda fila devono corrispondere per realizzare la moltiplicazione Matrix. La matrice che abbiamo ottenuto alla fine a causa della moltiplicazione della matrice sarà costituita dallo stesso ordine della matrice originale. Di seguito è mostrata un'illustrazione della moltiplicazione della matrice.
Utilizzando l'elenco nidificato per trovare la moltiplicazione di matrice
Una matrice può essere creata in Python come più di un semplice elenco nidificato, una sorta di elenco all'interno di un elenco. Una riga di una matrice corrisponde a ogni valore di un elenco nidificato. Vediamo un'istanza di un ciclo nidificato utilizzato per moltiplicare due matrici.
N = [[9, 1, 7],[3, 5, 6],
[4, 7, 8]]
M = [[2, 3, 5, 6],
[8, 9, 1, 2],
[4, 5, 9, 3]]
risultato = [[0, 0, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0]]
per u in gamma (len (n)):
per O nell'intervallo (len (m [0])):
per p nell'intervallo (len (m)):
risultato [u] [o] += n [u] [p] * m [p] [o]
per d di risultato:
stampa (d)
In questo esempio, useremo loop nidificati per eseguire un programma che moltiplica due matrici, ma prima di farlo, genereremo due matrici, "N" e "M", che sono 3 per 3 e 3- BY-4 in ordine, rispettivamente, nonché una terza matrice che ha l'ordine 3 per 4. Successivamente, passiamo attraverso un processo di iterazione in cui utilizziamo gli elementi delle righe in "N", le colonne in "M" e le righe in "M". Abbiamo applicato l'istruzione di stampa per visualizzare la moltiplicazione delle matrici definite.
Utilizzo della comprensione degli elenchi nidificati per trovare la moltiplicazione delle matrici
La comprensione dell'elenco nidificato è il processo di eseguire una comprensione dell'elenco insieme nella comprensione dell'elenco, risultando in una sorta di elenco nidificato
Sintassi:
new_list = [[expr. per un elemento elenco] per un elemento dell'elenco]Allo stesso modo, con lo stesso approccio ad anello nidificato, possiamo anche eseguire la moltiplicazione di due matrici usando facilmente il metodo della comprensione dell'elenco nidificato.
E = [[8, 1, 3],[8, 7, 3],
[7, 3, 5]]
R = [[2, 3, 6, 8],
[9, 8, 5, 3],
[1, 3, 8, 9]]
risultato = [[somma (f*g per f, g in zip (e_row, r_col))
per r_col in zip (*r)] per e_row in e]
per z in risultato:
Stampa (Z)
Per ottenere il totale dei prodotti di ogni moltiplicazione riga per colonna, citiamo sulle colonne all'interno della matrice "R" e le righe all'interno della matrice "E" nel programma. Per ottenere le colonne di matrice "R", utilizziamo il metodo Zip (). Richiediamo gli elementi della riga nella matrice "E" come secondo componente di una comprensione dell'elenco nidificato per calcolare la somma dei prodotti per ogni riga all'interno di questo elenco nidificato. Alla fine, la dichiarazione di stampa verrà impiegata.
Conclusione
In questa guida, abbiamo visto alcuni modi alternativi per calcolare manualmente l'aggiunta di matrice, la moltiplicazione e la trasposizione piuttosto che numpy. Questi approcci includono elenchi nidificati e comprensione degli elenchi nidificati. Inoltre, vengono presentati diversi programmi per dimostrare come questi approcci possono essere utilizzati e funzionano in modo diverso con l'aggiunta, la moltiplicazione e la trasposizione di una matrice.