Piton oferă structuri de date puternice numite liste, care pot stoca și manipula colecții de elemente. De asemenea, oferă multe modalități de a crea liste/matrice bidimensionale. Cu toate acestea, trebuie să cunoașteți diferențele dintre aceste moduri, deoarece ele pot crea complicații în cod care pot fi foarte greu de urmărit. În acest articol, vom explora modul corect de a folosi matrice/liste 2D în Python.
Folosind matrice/liste 2D în mod corect
Utilizarea corectă a tablourilor/listelor 2D implică înțelegerea structurii, accesarea elementelor și manipularea eficientă a datelor într-o grilă bidimensională. Când lucrați cu date structurate sau grile, matricele sau listele 2D pot fi utile. O matrice 2D este în esență o listă de liste, care reprezintă o structură de tip tabel cu rânduri și coloane.
Crearea unei liste 1-D
În Python, inițializarea unei colecții de elemente într-o secvență liniară necesită crearea unei matrice 1D, care este un proces fundamental. Deși Python nu are o structură de date încorporată numită „matrice 1D”, putem folosi o listă care poate atinge aceeași funcționalitate. Listele Python sunt dinamice și versatile, ceea ce le face o alegere excelentă pentru reprezentarea tablourilor 1D. Să începem prin a ne uita la modalitățile comune de a crea o matrice 1d de dimensiune N inițializată cu 0s.
Crearea listei 1D folosind metode naive
Inițializarea și popularea manuală a unei liste fără a utiliza funcții sau construcții avansate în Python este cunoscută ca crearea unei liste 1D folosind metode naive.
Python3
seria Fibonacci în java
N>=> 5> ar>=> [>0>]>*>N> print>(ar)> |
>
>
Ieșire
[0, 0, 0, 0, 0]>
Crearea listei 1D utilizând Lista de înțelegere
Aici înmulțim numărul de rânduri cu lista goală și, prin urmare, întreaga listă este creată cu fiecare element zero.
Python3
N>=> 5> arr>=> [>0> for> i>in> range>(N)]> print>(arr)> |
>
>
Ieșire
[0, 0, 0, 0, 0]>
Crearea unei liste 2-D
Utilizarea corectă a tablourilor/listelor 2D implică înțelegerea structurii, accesarea elementelor și manipularea eficientă a datelor într-o grilă bidimensională. Prin stăpânirea utilizării matricelor 2D, vă puteți îmbunătăți semnificativ capacitatea de a gestiona date complexe și de a efectua eficient diferite operațiuni.
Crearea listei 2D folosind Metoda naivă
Aici înmulțim numărul de coloane și, prin urmare, obținem o listă 1-D de dimensiune egală cu numărul de coloane și apoi o înmulțim cu numărul de rânduri, ceea ce duce la crearea unei liste 2-D.
Python3
rows, cols>=> (>5>,>5>)> arr>=> [[>0>]>*>cols]>*>rows> print>(arr)> |
>
>
Ieșire
[[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]]>
Notă: Utilizarea acestei metode poate provoca uneori comportamente neașteptate. În această metodă, fiecare rând va face referire la aceeași coloană. Aceasta înseamnă că, chiar dacă actualizăm un singur element al matricei, acesta va actualiza aceeași coloană din matricea noastră.
Piton
rows, cols>=> (>5>,>5>)> arr>=> [[>0>]>*>cols]>*>rows> print>(arr,>'before'>)> arr[>0>][>0>]>=> 1> # update only one element> print>(arr,>'after'>)> |
șir.conține java
>
>
Ieșire
([[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')>
Crearea listei 1D folosind Înțelegerea listei
Aici, practic, folosim conceptul de înțelegere a listei și aplicăm o buclă pentru o listă în interiorul unei liste și, prin urmare, creăm o listă 2-D.
Python3
rows, cols>=> (>5>,>5>)> arr>=> [[>0> for> i>in> range>(cols)]>for> j>in> range>(rows)]> print>(arr)> |
>
>
Ieșire
[[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]]>
Crearea listei 1D folosind Lista goală
Aici adăugăm zerouri ca elemente pentru un număr de coloane de ori și apoi adăugăm această listă 1-D în lista de rânduri goală și, prin urmare, creăm lista 2-D.
Python3
matrice în șir
arr>=>[]> rows, cols>=>5>,>5> for> i>in> range>(rows):> >col>=> []> >for> j>in> range>(cols):> >col.append(>0>)> >arr.append(col)> print>(arr)> |
>
>
Ieșire
[[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]]>
Inițializarea matricei 2D
Codul furnizat demonstrează două abordări diferite pentru inițializarea unei matrice 2D în Piton . În primul rând, matriceaarr>este inițializată folosind o listă de înțelegere 2D, în care fiecare rând este creat ca[0, 0, 0, 0, 0]>. Întreaga matrice este creată ca o listă de referințe la aceeași listă interioară, rezultând aliasing. Orice modificare adusă unui element dintr-un rând va fi reflectată în toate rândurile. Codul arată apoi o altă abordare folosind o înțelegere a listei imbricate pentru a crea matricea 2Darr>. Această metodă evită aliasarea prin crearea unei noi liste pentru fiecare rând, rezultând o matrice 2D adecvată.
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)> |
>
>
Ieșire
[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]>
Explicaţie:
Ne așteptăm ca doar primul element al primului rând să se schimbe la 1, dar primul element al fiecărui rând este schimbat la 1 în metoda 2a. Această funcționare particulară se datorează faptului că Python folosește liste superficiale pe care vom încerca să le înțelegem.
În metoda 1a, Python nu creează 5 obiecte întregi, ci creează doar un singur obiect întreg, iar toți indicii matricei arr indică același obiect int așa cum se arată.
Dacă atribuim indicele 0 unui alt număr întreg, să zicem 1, atunci se creează un nou obiect întreg cu valoarea 1 și apoi indicele 0 indică acum acest nou obiect int așa cum se arată mai jos
În mod similar, când creăm o matrice 2d ca arr = [[0]*cols]*rânduri, extindem în esență analogia de mai sus.
- Este creat un singur obiect întreg.
- Este creată o singură listă 1d și toți indicii ei indică același obiect int din punctul 1.
- Acum, arr[0], arr[1], arr[2] …. arr[n-1] toate indică același obiect listă de mai sus la punctul 2.
Configurația de mai sus poate fi vizualizată în imaginea de mai jos.
Acum să schimbăm primul element din primul rând al arr ca arr[0][0] = 1
- arr[0] indică un singur obiect listă pe care l-am creat mai sus. (Amintiți-vă arr[1], arr[2] ...arr[n-1] toate indică și ele același obiect listă).
- Atribuirea lui arr[0][0] va crea un nou obiect int cu valoarea 1 și arr[0][0] va indica acum acest nou obiect int.(și la fel va fi arr[1][0], arr [2][0] … arr[n-1][0])
Acest lucru poate fi văzut clar în imaginea de mai jos.
Deci, atunci când matricele 2d sunt create astfel, modificarea valorilor la un anumit rând va afecta toate rândurile, deoarece există în esență un singur obiect întreg și un singur obiect listă care este referit de toate rândurile matricei.
După cum v-ați aștepta, identificarea erorilor cauzate de o astfel de utilizare a listelor superficiale este dificilă. Prin urmare, cel mai bun mod de a declara o matrice 2d este
Python3
rows, cols>=> (>5>,>5>)> print>([[>0> for> i>in> range>(cols)]>for> j>in> range>(rows)])> |
>
>
Ieșire
[[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]]>
Această metodă creează 5 obiecte listă separate, spre deosebire de metoda 2a. O modalitate de a verifica acest lucru este utilizarea operatorului „is” care verifică dacă cei doi operanzi se referă la același obiect.
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>])> |
cod gri
>
>
Ieșire
False True>