Python nodrošina jaudīgas datu struktūras, ko sauc par sarakstiem, kas var uzglabāt un manipulēt ar elementu kolekcijām. Nodrošina arī daudzus veidus, kā izveidot 2-dimensiju sarakstus/masīvus. Tomēr ir jāzina atšķirības starp šiem veidiem, jo tie var radīt sarežģījumus kodā, ko var būt ļoti grūti izsekot. Šajā rakstā mēs izpētīsim pareizo veidu, kā Python izmantot 2D masīvus/sarakstus.
Pareiza 2D masīvu/sarakstu izmantošana
Pareiza 2D masīvu/sarakstu izmantošana ietver struktūras izpratni, piekļuvi elementiem un efektīvu datu manipulāciju divdimensiju režģī. Strādājot ar strukturētiem datiem vai režģiem, 2D masīvi vai saraksti var būt noderīgi. 2D masīvs būtībā ir sarakstu saraksts, kas attēlo tabulai līdzīgu struktūru ar rindām un kolonnām.
1-D saraksta izveide
Programmā Python, lai inicializētu elementu kolekciju lineārā secībā, ir jāizveido 1D masīvs, kas ir būtisks process. Lai gan Python nav iebūvētas datu struktūras, ko sauc par “1D masīvu”, mēs varam izmantot sarakstu, kas var nodrošināt tādu pašu funkcionalitāti. Python saraksti ir dinamiski un daudzpusīgi, padarot tos par lielisku izvēli 1D masīvu attēlošanai. Sāksim, aplūkojot izplatītākos veidus, kā izveidot N izmēra 1 d masīvu, kas inicializēts ar 0.
1D saraksta izveide, izmantojot naivās metodes
Manuāla saraksta inicializācija un aizpildīšana, neizmantojot Python papildu līdzekļus vai konstrukcijas, ir pazīstama kā 1D saraksta izveide, izmantojot naivās metodes.
Python3
N>=> 5> ar>=> [>0>]>*>N> print>(ar)> |
>
>
Izvade
[0, 0, 0, 0, 0]>
1D saraksta izveide, izmantojot saraksta izpratni
Šeit mēs reizinām rindu skaitu ar tukšo sarakstu, un tādējādi viss saraksts tiek izveidots ar katru elementu nulle.
Python3
N>=> 5> arr>=> [>0> for> i>in> range>(N)]> print>(arr)> |
>
>
java ir vienāds
Izvade
[0, 0, 0, 0, 0]>
2-D saraksta izveide
Pareiza 2D masīvu/sarakstu izmantošana ietver struktūras izpratni, piekļuvi elementiem un efektīvu datu manipulāciju divdimensiju režģī. Apgūstot 2D masīvu lietošanu, jūs varat ievērojami uzlabot spēju apstrādāt sarežģītus datus un efektīvi veikt dažādas darbības.
2D saraksta izveide, izmantojot Naiva metode
Šeit mēs reizinām kolonnu skaitu, un tādējādi mēs iegūstam 1-D sarakstu, kura lielums ir vienāds ar kolonnu skaitu, un pēc tam reizina to ar rindu skaitu, kā rezultātā tiek izveidots 2-D saraksts.
Python3
rows, cols>=> (>5>,>5>)> arr>=> [[>0>]>*>cols]>*>rows> print>(arr)> |
>
>
Izvade
[[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]]>
Piezīme: Šīs metodes izmantošana dažkārt var izraisīt neparedzētu uzvedību. Izmantojot šo metodi, katra rinda būs atsauce uz vienu un to pašu kolonnu. Tas nozīmē, ka pat tad, ja mēs atjaunināsim tikai vienu masīva elementu, tas atjauninās to pašu kolonnu mūsu masīvā.
Python
rows, cols>=> (>5>,>5>)> arr>=> [[>0>]>*>cols]>*>rows> print>(arr,>'before'>)> arr[>0>][>0>]>=> 1> # update only one element> print>(arr,>'after'>)> |
>
>
Izvade
([[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 saraksta izveide, izmantojot Saraksta izpratne
Šeit mēs būtībā izmantojam saraksta izpratnes jēdzienu un sarakstam piemērojam cilpu sarakstā un tādējādi izveidojam 2-D sarakstu.
Python3
java ir nulle
rows, cols>=> (>5>,>5>)> arr>=> [[>0> for> i>in> range>(cols)]>for> j>in> range>(rows)]> print>(arr)> |
>
>
Izvade
[[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 saraksta izveide, izmantojot Tukšs saraksts
Šeit mēs pievienojam nulles kā elementus vairākām kolonnām un pēc tam pievienojam šo 1-D sarakstu tukšo rindu sarakstam un tādējādi izveidojam 2-D sarakstu.
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)> |
>
>
Izvade
[[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]]>
Notiek 2D masīva inicializācija
Norādītais kods parāda divas dažādas pieejas 2D masīva inicializācijai Python . Pirmkārt, masīvsarr>tiek inicializēts, izmantojot 2D saraksta izpratni, kur katra rinda tiek izveidota kā[0, 0, 0, 0, 0]>. Viss masīvs tiek izveidots kā atsauču saraksts uz to pašu iekšējo sarakstu, kā rezultātā tiek izmantota aizstājvārds. Jebkuras izmaiņas, kas veiktas elementā vienā rindā, tiks atspoguļotas visās rindās. Pēc tam kods parāda citu pieeju, izmantojot ligzdotu saraksta izpratni, lai izveidotu 2D masīvuarr>. Šī metode ļauj izvairīties no aizstājvārdu izmantošanas, katrai rindai izveidojot jaunu sarakstu, kā rezultātā tiek iegūts pareizs 2D masīvs.
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)> |
>
>
Izvade
[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]>
Paskaidrojums:
Mēs sagaidām, ka tikai pirmās rindas pirmais elements mainīsies uz 1, bet katras rindas pirmais elements tiek mainīts uz 1 2.a metodē. Šī savdabīgā darbība ir tāpēc, ka Python izmanto seklus sarakstus, kurus mēs centīsimies saprast.
1.a metodē Python neizveido 5 veselu skaitļu objektus, bet izveido tikai vienu veselu skaitļu objektu, un visi masīva arr indeksi norāda uz to pašu int objektu, kā parādīts attēlā.
Ja mēs piešķiram 0. indeksu citam veselam skaitlim, piemēram, 1, tad tiek izveidots jauns vesela skaitļa objekts ar vērtību 1 un tad 0. indekss tagad norāda uz šo jauno int objektu, kā parādīts zemāk.
Līdzīgi, veidojot 2d masīvu kā arr = [[0]*cols]*rows, mēs būtībā paplašinām iepriekš minēto analoģiju.
- Tiek izveidots tikai viens vesela skaitļa objekts.
- Tiek izveidots viens 1d saraksts, un visi tā indeksi norāda uz vienu un to pašu int objektu 1. punktā.
- Tagad, arr[0], arr[1], arr[2] …. arr[n-1] visi norāda uz vienu un to pašu saraksta objektu iepriekš 2. punktā.
Iepriekš minēto iestatījumu var vizualizēt zemāk esošajā attēlā.
Tagad mainīsim pirmo elementu pirmajā arr rindā kā arr[0][0] = 1
- arr[0] norāda uz vienu saraksta objektu, kuru izveidojām iepriekš. (Atcerieties, arr[1], arr[2] …arr[n-1] arī norāda uz vienu un to pašu saraksta objektu).
- Piešķirot arr[0][0], tiks izveidots jauns int objekts ar vērtību 1, un arr[0][0] tagad norādīs uz šo jauno int objektu. (tāpat arī arr[1][0], arr [2][0] … arr[n-1][0])
To var skaidri redzēt zemāk esošajā attēlā.
Tātad, kad šādi tiek izveidoti 2D masīvi, vērtību maiņa noteiktā rindā ietekmēs visas rindas, jo būtībā ir tikai viens vesela skaitļa objekts un tikai viens saraksta objekts, uz kuru atsaucas visas masīva rindas.
Kā jūs varētu gaidīt, ir grūti izsekot kļūdas, ko izraisa šāda seklu sarakstu izmantošana. Tāpēc labāks veids, kā deklarēt 2D masīvu, ir
Python3
rows, cols>=> (>5>,>5>)> print>([[>0> for> i>in> range>(cols)]>for> j>in> range>(rows)])> |
>
>
Izvade
[[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]]>
Šī metode atšķirībā no 2a metodes izveido 5 atsevišķus saraksta objektus. Viens veids, kā to pārbaudīt, ir izmantot operatoru “ir”, kas pārbauda, vai abi operandi attiecas uz vienu un to pašu objektu.
daļējs atvasinājuma simbols latekss
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>])> |
>
>
Izvade
False True>