Hvordan beregne matriser i Python uten numpy
En matrise kan holde strenger, tall og andre datatyper av objekter. I en matrise er data stablet i begge kolonnene og rader. En nøkkel datastruktur som støtter beregninger innen vitenskap og matematikk er matrisen. Siden Python ikke gir en innebygd type for et matriksobjekt, behandler vi en av listen mellom lister eller til og med en nestet liste som en matrise.
Hvordan matriser i Python fungerer
Data er skrevet i en todimensjonal matrise for å generere en matrise. Prosedyren er som følger:
[[1 3 5 7 9][2 4 6 8 10]
[0 8 7 4]]
Den har en 3 med 5 matrise som visning. Derfor er størrelsen 3 med 5. Dataene i denne matrisen består av objekter av enten datatypen heltall. Den øverste raden, rad1, har verdiene 1, 3, 5, 7 og 9, mens rad2, sammen med Row3, har verdiene (2, 4, 6, 8) og henholdsvis (0, 8, 7, 4). Kolonne1 inneholder verdier på (1, 2, 0) samt kolonne2 har verdier på (3, 4, 8) og så videre.
Python gjør det mulig for oss å lagre alle data i en matrise med to dimensjoner. Vi kan legge til matriser, multiplisere dem, transponere dem og utføre andre operasjoner på en matrise. Ved å bruke matriser kan vi bygge en Python -matrise og bruke den på samme måte. La oss snakke om forskjellige eksempler på Python -matriser.
Python Matrix Addition
Vi tar de to matriser og legger dem til å iterere gjennom dem ved hjelp av en nestet for sløyfe.
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 (matrise1)
for rad i rekkevidde (Len (Matrix1)):
For kolonne i område (LEN (Matrix2 [0])):
Matrix4 [rad] [kolonne] = matrise1 [rad] [kolonne] + matrise2 [rad] [kolonne] + matrise3 [rad] [kolonne]
trykk ("Summen av matriser er =", Matrix4)
Til å begynne med, i stedet for å bruke Numpy, bygde vi direkte tre matriser med bestilling 3-til-3. Vi spesifiserte bestillingen eller lengden på Matrix 1 som henholdsvis Len () -funksjon og andre. Ved hjelp av nestede løkker ble de tre matriser først lagt til. Totalt av de tre matriser ble deretter spesifisert som Matrix 4, og vi brukte print () -funksjonen for å vise resultatene.
Transponere en matrise i Python
Ved å bytte elementene i matrisens kolonner og rader, kunne vi transponere dem. Ved hjelp av forskjellige eksempler vil vi demonstrere hvordan vi kan oppnå en transponering av en matrise ved bruk av Python uten numpy.
En matrises transponering er representert med symbolet på. Anta for eksempel at vi har en matrise “A” som har rekkefølgen på:
3-by-2
Da er transponering av a:
2-by-3-matrise
Beregning av transponering av en matrise ved hjelp av en nestet sløyfe
Den nestede sløyfen kan brukes til å gjentatte ganger iterere gjennom kolonnene og radene med til og med en nestet liste. Sett inn elementet i "ith" -rekken og "jth" -kolonnen til matrise f sammen med "jth" -rekken og "ith" -kolonnen til matrisen "f^t" for å oppnå transponering av matrisen. “F^t” vil være en 2-by-3-matrise forutsatt at “F” er en 3-by-2-matrise.
F = [[2, 3],[5, 7],
[8, 1]]
F_t = [[0, 0, 0],
[0, 0, 0]]
For Q i rekkevidde (Len (F)):
for w i rekkevidde (len (f [0])):
F_t [w] [q] = f [q] [w]
For Q i F_T:
trykk (q)
En transponeringsmatrise av den originale matrisen og en matrise “F” med en 3-til-2-ordre opprettes først. Det forrige programmet bruker nestede “for” -løkker, iterert kontinuerlig over hver rad og deretter hver kolonne. Ved hver iterasjon legger vi til et element fra “F [q] [w]” til “ft [w] [q]”. Til slutt utfører vi metoden Print () for å skildre transponering.
Ved hjelp av en nestet listeforståelse for å finne transponering av matrisen
En nestet liste produseres når en listeforståelse utføres i en annen listeforståelse. Følgende er syntaks for å forstå nestede lister:
new_list = [[expr. for et listeelement] for et listeelement]På samme måte kan vi få en matriks transponering ved hjelp av nestet listeforståelse i en slik nestet sløyfetilnærming.
J = [[1, 3],[4, 6],
[9, 2]]
J_t = [[j [v] [c] for v in range (len (j))] for c in range (len (j [0]))]
for C i J_T:
trykk (c)
Vi starter med å lage matrise “j”, med bestillingen 3-by-2. Den nestede listeforståelsen i koden foregående løkker over matrisens medlemmer en gang om gangen og setter inn elementene i “J [V]” et sted på stedet “J_T [V]”. Matrisens kolonner er iterert gjennom den første delen av en slik nestet listeforståelse, mens radene gjentas i den andre kolonnen.
Multiplikasjon av to matriser i Python
Den binære prosessen med å multiplisere matriser skaper matrisen ved hjelp av to matriser. Ved å bruke nestede løkker og listeforståelse, kan vi multiplisere matriser i Python.
Den første matrisens kolonne og antall andre rads må samsvare med å oppnå matriksmultiplikasjon. Matrisen vi fikk på slutten på grunn av matriksmultiplikasjon vil bestå av samme rekkefølge som den opprinnelige matrisen. En illustrasjon av matriksmultiplikasjon vises nedenfor.
Bruker nestet liste for å finne multiplikasjon av matrise
En matrise kan opprettes i Python som mer enn bare en nestet liste, en slags liste inne i en liste. En rad i en matrise tilsvarer hver verdi av en nestet liste. La oss se en forekomst av en nestet sløyfe som brukes til å multiplisere to matriser.
N = [[9, 1, 7],[3, 5, 6],
[4, 7, 8]]
M = [[2, 3, 5, 6],
[8, 9, 1, 2],
[4, 5, 9, 3]]
Resultat = [[0, 0, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0]]
for u i rekkevidde (len (n)):
for o i rekkevidde (len (m [0])):
for p i rekkevidde (len (m)):
Resultat [u] [o] += n [u] [p] * m [p] [o]
for d i resultatet:
trykk (d)
I dette eksemplet bruker vi nestede løkker for å utføre et program som multipliserer to matriser, men før vi gjør det, vil vi generere to matriser, “N” og “M”, som er 3-til-3 og 3- BY-4 i henhold til henholdsvis ordre, så vel som en tredje matrise som har bestill 3-by-4. Deretter går vi gjennom en iterasjonsprosess der vi bruker elementene i radene i “N”, kolonnene i “M” og radene i “M”. Vi brukte utskriftserklæringen for å vise multiplikasjonen av de definerte matriser.
Bruke nestet listeforståelse for å finne multiplikasjon av matriser
Nestet listeforståelse er prosessen med å utføre en listeforståelse sammen innenfor listeforståelse, noe som resulterer i en slags nestet liste
Syntaks:
new_list = [[expr. for et listeelement] for et listeelement]På samme måte med den samme nestede sløyfetilnærmingen, kan vi også utføre multiplikasjonen av to matriser ved å bruke metoden for nestet listeforståelse enkelt.
E = [[8, 1, 3],[8, 7, 3],
[7, 3, 5]]
R = [[2, 3, 6, 8],
[9, 8, 5, 3],
[1, 3, 8, 9]]
Resultat = [[sum (f*g for f, g i zip (e_row, r_col))
for r_col i zip (*r)] for e_row i e]
for z i resultatet:
trykk (z)
For å få totalen av produktene fra hver rekke for kolonne, itererer vi over kolonnene inne i matrisen “R” og radene inne i matrisen “E” i programmet. For å få kolonnene med matrise “R”, bruker vi ZIP () -metoden. Vi krever elementene i raden i "E" -matrisen som den andre komponenten i en nestet listeforståelse for å beregne summen av produkter for hver rad inne i denne nestede listen. Til slutt vil utskriftserklæringen bli ansatt.
Konklusjon
I denne guiden har vi sett noen få alternative måter å manuelt beregne matriks tillegg, multiplikasjon og transponering i stedet for numpy. Disse tilnærmingene inkluderer nestede lister samt forståelse av nestede lister. I tillegg presenteres flere programmer for å demonstrere hvordan disse tilnærmingene kan brukes og fungerer annerledes med tillegg, multiplikasjon og transponering av en matrise.