Python gir kraftige datastrukturer kalt lister, som kan lagre og manipulere samlinger av elementer. Gir også mange måter å lage 2-dimensjonale lister/matriser på. Imidlertid må man vite forskjellene mellom disse måtene fordi de kan skape komplikasjoner i kode som kan være svært vanskelig å spore ut. I denne artikkelen vil vi utforske den riktige måten å bruke 2D-matriser/-lister i Python.
Bruk av 2D-matriser/-lister på riktig måte
Å bruke 2D-matriser/-lister på riktig måte innebærer å forstå strukturen, få tilgang til elementer og effektivt manipulere data i et todimensjonalt rutenett. Når du arbeider med strukturerte data eller rutenett, kan 2D-matriser eller -lister være nyttige. En 2D-matrise er i hovedsak en liste over lister, som representerer en tabelllignende struktur med rader og kolonner.
ubuntu bygge viktig
Opprette en 1D-liste
I Python krever initialisering av en samling av elementer i en lineær sekvens å lage en 1D-matrise, som er en grunnleggende prosess. Selv om Python ikke har en innebygd datastruktur kalt en ‘1D array’, kan vi bruke en liste som kan oppnå samme funksjonalitet. Python-lister er dynamiske og allsidige, noe som gjør dem til et utmerket valg for å representere 1D-matriser. La oss starte med å se på vanlige måter å lage en 1d-matrise med størrelse N initialisert med 0s.
Opprette 1D-liste ved hjelp av naive metoder
Manuell initialisering og fylling av en liste uten å bruke noen avanserte funksjoner eller konstruksjoner i Python er kjent som å lage en 1D-liste ved hjelp av naive metoder.
Python3
N>=> 5> ar>=> [>0>]>*>N> print>(ar)> |
>
>
Produksjon
[0, 0, 0, 0, 0]>
Opprette 1D-liste ved hjelp av listeforståelse
Her multipliserer vi antall rader med den tomme listen, og derfor opprettes hele listen med hvert element null.
Python3
N>=> 5> arr>=> [>0> for> i>in> range>(N)]> print>(arr)> |
>
>
Produksjon
[0, 0, 0, 0, 0]>
Opprette en 2D-liste
Å bruke 2D-matriser/-lister på riktig måte innebærer å forstå strukturen, få tilgang til elementer og effektivt manipulere data i et todimensjonalt rutenett. Ved å mestre bruken av 2D-matriser kan du betydelig forbedre din evne til å håndtere komplekse data og effektivt utføre ulike operasjoner.
Opprette 2D-liste ved hjelp av Naiv metode
Her multipliserer vi antall kolonner, og derfor får vi 1-D-listen med størrelse lik antall kolonner og deretter multiplisere den med antall rader som resulterer i opprettelsen av en 2-D-liste.
konvertere et heltall til en streng
Python3
rows, cols>=> (>5>,>5>)> arr>=> [[>0>]>*>cols]>*>rows> print>(arr)> |
>
>
Produksjon
[[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]>
Merk: Bruk av denne metoden kan noen ganger føre til uventet oppførsel. I denne metoden vil hver rad referere til samme kolonne. Dette betyr at selv om vi bare oppdaterer ett element i arrayet, vil det oppdatere den samme kolonnen i arrayet vårt.
Python
rows, cols>=> (>5>,>5>)> arr>=> [[>0>]>*>cols]>*>rows> print>(arr,>'before'>)> arr[>0>][>0>]>=> 1> # update only one element> print>(arr,>'after'>)> |
>
>
Produksjon
([[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]], 'before') ([[1, 0, 0, 0, 0], [1, 0, 0, 0, 0], [1, 0, 0, 0, 0], [1, 0, 0, 0, 0], [1, 0, 0, 0, 0]], 'after')>
Opprette 1D-liste ved hjelp av Listeforståelse
Her bruker vi i utgangspunktet konseptet med listeforståelse og bruker en løkke for en liste i en liste og lager derfor en 2D-liste.
Python3
hva er eksport i linux
rows, cols>=> (>5>,>5>)> arr>=> [[>0> for> i>in> range>(cols)]>for> j>in> range>(rows)]> print>(arr)> |
>
>
Produksjon
[[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]>
Opprette 1D-liste ved hjelp av Tom liste
Her legger vi til nuller som elementer for et antall kolonner ganger og legger deretter til denne 1-D-listen i den tomme radlisten og lager dermed 2-D-listen.
Python3
arr>=>[]> rows, cols>=>5>,>5> for> i>in> range>(rows):> >col>=> []> >for> j>in> range>(cols):> >col.append(>0>)> >arr.append(col)> print>(arr)> |
>
>
Produksjon
[[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]>
Initialiserer 2D Array
Den medfølgende koden demonstrerer to forskjellige tilnærminger til å initialisere en 2D-array i Python . Først matrisenarr>initialiseres ved hjelp av en 2D-listeforståelse, hvor hver rad opprettes som[0, 0, 0, 0, 0]>. Hele matrisen opprettes som en liste med referanser til den samme indre listen, noe som resulterer i aliasing. Enhver endring som gjøres i et element i én rad, vil reflekteres i alle rader. Koden viser deretter en annen tilnærming ved å bruke en nestet listeforståelse for å lage 2D-matrisenarr>. Denne metoden unngår aliasing ved å lage en ny liste for hver rad, noe som resulterer i en riktig 2D-array.
Javascript lastet ned
Python3
# Python 3 program to demonstrate working> # of method 1 and method 2.> rows, cols>=> (>5>,>5>)> # method 2 1st approach> arr>=> [[>0>]>*>cols]>*>rows> # lets change the first element of the> # first row to 1 and print the array> arr[>0>][>0>]>=> 1> for> row>in> arr:> >print>(row)> # method 2 2nd approach> arr>=> [[>0> for> i>in> range>(cols)]>for> j>in> range>(rows)]> # again in this new array lets change> # the first element of the first row> # to 1 and print the array> arr[>0>][>0>]>=> 1> for> row>in> arr:> >print>(row)> |
>
>
Produksjon
[1, 0, 0, 0, 0] [1, 0, 0, 0, 0] [1, 0, 0, 0, 0] [1, 0, 0, 0, 0] [1, 0, 0, 0, 0] [1, 0, 0, 0, 0] [0, 0, 0, 0, 0] [0, 0, 0, 0, 0] [0, 0, 0, 0, 0] [0, 0, 0, 0, 0]>
Forklaring:
Vi forventer at bare det første elementet i den første raden endres til 1, men det første elementet i hver rad endres til 1 i metode 2a. Denne særegne funksjonen er fordi Python bruker grunne lister som vi vil prøve å forstå.
I metode 1a oppretter ikke Python 5 heltallsobjekter, men lager bare ett heltallsobjekt, og alle indeksene til array arr peker til det samme int-objektet som vist.
Hvis vi tilordner den 0. indeksen til et annet heltall, si 1, opprettes et nytt heltallsobjekt med verdien 1, og deretter peker den 0. indeksen til dette nye int-objektet som vist nedenfor
På samme måte, når vi lager en 2d-matrise som arr = [[0]*cols]*rader, utvider vi i hovedsak analogien ovenfor.
- Bare ett heltallsobjekt opprettes.
- En enkelt 1d-liste opprettes og alle indeksene peker til det samme int-objektet i punkt 1.
- Nå, arr[0], arr[1], arr[2] …. arr[n-1] peker alle til det samme listeobjektet ovenfor i punkt 2.
Oppsettet ovenfor kan visualiseres i bildet nedenfor.
La oss nå endre det første elementet i første rad med arr som arr[0][0] = 1
- arr[0] peker på det enkle listeobjektet vi laget ovenfor. (Husk at arr[1], arr[2] …arr[n-1] peker også på det samme listeobjektet).
- Tilordningen av arr[0][0] vil opprette et nytt int-objekt med verdien 1 og arr[0][0] vil nå peke til dette nye int-objektet.(og det vil også arr[1][0], arr [2][0] … arr[n-1][0])
Dette kan tydelig sees på bildet under.
Så når 2d-matriser opprettes som dette, vil endring av verdier på en bestemt rad påvirke alle radene siden det i hovedsak bare er ett heltallsobjekt og bare ett listeobjekt som refereres til av alle radene i matrisen.
Som du forventer, er det vanskelig å spore opp feil forårsaket av slik bruk av grunne lister. Derfor er den bedre måten å erklære en 2d-matrise på
Python3
rows, cols>=> (>5>,>5>)> print>([[>0> for> i>in> range>(cols)]>for> j>in> range>(rows)])> |
>
>
Produksjon
[[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]>
Denne metoden lager 5 separate listeobjekter, i motsetning til metode 2a. En måte å sjekke dette på er ved å bruke 'er'-operatoren som sjekker om de to operandene refererer til det samme objektet.
tilpasset unntak i java
Python3
rows, cols>=> (>5>,>5>)> # method 2 2nd approach> arr>=> [[>0> for> i>in> range>(cols)]>for> j>in> range>(rows)]> # check if arr[0] and arr[1] refer to> # the same object> print>(arr[>0>]>is> arr[>1>])># prints False> # method 2 1st approach> arr>=> [[>0>]>*>cols]>*>rows> # check if arr[0] and arr[1] refer to the same object prints True because there is only one> #list object being created.> print>(arr[>0>]>is> arr[>1>])> |
>
>
Produksjon
False True>