Python tarjoaa tehokkaita tietorakenteita, joita kutsutaan listoiksi ja jotka voivat tallentaa ja käsitellä elementtikokoelmia. Tarjoaa myös monia tapoja luoda 2-ulotteisia luetteloita/taulukoita. On kuitenkin tiedettävä näiden tapojen väliset erot, koska ne voivat aiheuttaa koodiin komplikaatioita, joita voi olla erittäin vaikea jäljittää. Tässä artikkelissa tutkimme oikeaa tapaa käyttää 2D-taulukoita/luetteloita Pythonissa.
2D-taulukoiden/-luetteloiden käyttäminen oikealla tavalla
2D-taulukoiden/luetteloiden oikea käyttö edellyttää rakenteen ymmärtämistä, elementtien käyttöä ja tietojen tehokasta käsittelyä kaksiulotteisessa ruudukossa. Kun työskentelet strukturoidun datan tai ruudukoiden kanssa, 2D-taulukot tai luettelot voivat olla hyödyllisiä. 2D-taulukko on pohjimmiltaan luettelo luetteloista, joka edustaa taulukkomaista rakennetta, jossa on rivejä ja sarakkeita.
1-D-luettelon luominen
Pythonissa elementtikokoelman alustaminen lineaarisessa järjestyksessä edellyttää 1D-taulukon luomista, mikä on perusprosessi. Vaikka Pythonissa ei ole sisäänrakennettua tietorakennetta, jota kutsutaan '1D-taulukoksi', voimme käyttää luetteloa, jolla voidaan saavuttaa samat toiminnot. Python-listat ovat dynaamisia ja monipuolisia, joten ne ovat erinomainen valinta 1D-taulukoiden esittämiseen. Aloitetaan tarkastelemalla yleisiä tapoja luoda 1d-kokoinen N-taulukko, joka on alustettu nollalla.
1D-listan luominen naiiveilla menetelmillä
Luettelon manuaalinen alustaminen ja täyttäminen ilman Pythonin lisäominaisuuksia tai rakenteita tunnetaan 1D-luettelon luomisena naiiveilla menetelmillä.
Python 3
N>=> 5> ar>=> [>0>]>*>N> print>(ar)> |
>
>
Lähtö
[0, 0, 0, 0, 0]>
1D-luettelon luominen luettelon ymmärtämisen avulla
Tässä kerromme rivien lukumäärän tyhjällä listalla ja näin ollen koko luettelo luodaan jokaisen elementin nollalla.
Python 3
N>=> 5> arr>=> [>0> for> i>in> range>(N)]> print>(arr)> |
>
>
Lähtö
[0, 0, 0, 0, 0]>
2D-luettelon luominen
2D-taulukoiden/luetteloiden oikea käyttö edellyttää rakenteen ymmärtämistä, elementtien käyttöä ja tietojen tehokasta käsittelyä kaksiulotteisessa ruudukossa. Hallitsemalla 2D-taulukoiden käytön voit parantaa merkittävästi kykyäsi käsitellä monimutkaisia tietoja ja suorittaa tehokkaasti erilaisia toimintoja.
2D-luettelon luominen käyttämällä Naiivi menetelmä
Tässä kerromme sarakkeiden lukumäärän ja näin ollen saamme 1-D-luettelon, jonka koko on yhtä suuri kuin sarakkeiden lukumäärä, ja kerromme sen sitten rivien lukumäärällä, mikä johtaa 2-D-luettelon luomiseen.
Python 3
jos muuten javassa
rows, cols>=> (>5>,>5>)> arr>=> [[>0>]>*>cols]>*>rows> print>(arr)> |
>
>
Lähtö
[[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]]>
Huomautus: Tämän menetelmän käyttäminen voi joskus aiheuttaa odottamattomia toimintoja. Tässä menetelmässä jokainen rivi viittaa samaan sarakkeeseen. Tämä tarkoittaa, että vaikka päivitämme vain yhden taulukon elementin, se päivittää saman sarakkeen taulukossamme.
Python
rows, cols>=> (>5>,>5>)> arr>=> [[>0>]>*>cols]>*>rows> print>(arr,>'before'>)> arr[>0>][>0>]>=> 1> # update only one element> print>(arr,>'after'>)> |
>
>
Lähtö
([[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')>
1D-luettelon luominen käyttämällä Listan ymmärtäminen
Tässä käytämme pohjimmiltaan luettelon ymmärtämisen käsitettä ja käytämme silmukkaa listalle luettelon sisällä ja luomme siten 2-D-luettelon.
Python 3
nopea lajittelu java
rows, cols>=> (>5>,>5>)> arr>=> [[>0> for> i>in> range>(cols)]>for> j>in> range>(rows)]> print>(arr)> |
>
>
Lähtö
[[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]]>
1D-luettelon luominen käyttämällä Tyhjä lista
Tässä lisäämme nollia elementeiksi useille sarakkeille ja sitten lisäämme tämän 1-D-luettelon tyhjään riviluetteloon ja luomme siten 2-D-luettelon.
Python 3
arr>=>[]> rows, cols>=>5>,>5> for> i>in> range>(rows):> >col>=> []> >for> j>in> range>(cols):> >col.append(>0>)> >arr.append(col)> print>(arr)> |
>
>
Lähtö
[[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]]>
Alustetaan 2D-taulukkoa
Toimitettu koodi esittelee kaksi erilaista lähestymistapaa 2D-taulukon alustamiseen Python . Ensinnäkin joukkoarr>alustetaan 2D-luettelon ymmärtämisellä, jossa jokainen rivi luodaan muodossa[0, 0, 0, 0, 0]>. Koko taulukko luodaan luettelona viittauksista samaan sisäluetteloon, mikä johtaa aliasointiin. Kaikki yhden rivin elementtiin tehdyt muutokset näkyvät kaikilla riveillä. Koodi näyttää sitten toisen lähestymistavan käyttämällä sisäkkäisen luettelon ymmärtämistä 2D-taulukon luomiseenarr>. Tämä menetelmä välttää aliasoinnin luomalla uuden luettelon jokaiselle riville, jolloin saadaan oikea 2D-taulukko.
Python 3
# 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)> |
>
>
Lähtö
[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]>
Selitys:
Odotamme vain ensimmäisen rivin ensimmäisen elementin muuttuvan arvoon 1, mutta jokaisen rivin ensimmäinen elementti muuttuu 1:ksi menetelmässä 2a. Tämä erikoinen toiminta johtuu siitä, että Python käyttää matalia listoja, joita yritämme ymmärtää.
Menetelmässä 1a Python ei luo viittä kokonaislukuobjektia, vaan luo vain yhden kokonaislukuobjektin, ja kaikki taulukon arr-indeksit osoittavat samaan int-objektiin kuten kuvassa.
Jos määritämme 0. indeksin toiselle kokonaisluvulle, esimerkiksi 1:lle, luodaan uusi kokonaislukuobjekti arvolla 1 ja sitten 0. indeksi osoittaa nyt tähän uuteen int-objektiin alla olevan kuvan mukaisesti.
Vastaavasti, kun luomme 2d-taulukon muodossa arr = [[0]*cols]*rivit, laajennamme olennaisesti yllä olevaa analogiaa.
- Vain yksi kokonaislukuobjekti luodaan.
- Yksittäinen 1d-lista luodaan ja kaikki sen indeksit osoittavat samaan int-objektiin kohdassa 1.
- Nyt, arr[0], arr[1], arr[2] …. arr[n-1] kaikki osoittavat samaan luetteloobjektiin edellä kohdassa 2.
Yllä oleva asetus voidaan visualisoida alla olevassa kuvassa.
Muutetaan nyt arr:n ensimmäisen rivin ensimmäinen elementti muotoon arr[0][0] = 1
- arr[0] osoittaa yksittäiseen listaobjektiin, jonka loimme edellä. (Muista arr[1], arr[2] …arr[n-1] kaikki osoittavat myös samaan listaobjektiin).
- Määritys arr[0][0] luo uuden int-objektin, jonka arvo on 1 ja arr[0][0] osoittaa nyt tähän uuteen int-objektiin. (ja niin myös arr[1][0], arr [2][0] … arr[n-1][0])
Tämä näkyy selvästi alla olevasta kuvasta.
Joten kun 2d-taulukoita luodaan näin, arvojen muuttaminen tietyllä rivillä vaikuttaa kaikkiin riveihin, koska taulukon kaikki rivit viittaavat olennaisesti vain yhteen kokonaislukuobjektiin ja vain yhteen luetteloobjektiin.
Kuten arvata saattaa, tällaisen matalien listojen käytön aiheuttamien virheiden jäljittäminen on vaikeaa. Siksi parempi tapa ilmoittaa 2d-taulukko on
Python 3
rows, cols>=> (>5>,>5>)> print>([[>0> for> i>in> range>(cols)]>for> j>in> range>(rows)])> |
>
>
Lähtö
[[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]]>
Tämä menetelmä luo 5 erillistä listaobjektia, toisin kuin menetelmä 2a. Yksi tapa tarkistaa tämä on käyttää 'is'-operaattoria, joka tarkistaa, viittaavatko nämä kaksi operandia samaan objektiin.
jono merkkijonossa
Python 3
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>])> |
>
>
Lähtö
False True>