Python biedt krachtige datastructuren, lijsten genaamd, die verzamelingen elementen kunnen opslaan en manipuleren. Biedt ook vele manieren om tweedimensionale lijsten/arrays te maken. Je moet echter de verschillen tussen deze manieren kennen, omdat ze complicaties in de code kunnen veroorzaken die erg moeilijk te achterhalen zijn. In dit artikel onderzoeken we de juiste manier om 2D-arrays/lijsten in Python te gebruiken.
2D-arrays/lijsten op de juiste manier gebruiken
Om 2D-arrays/lijsten op de juiste manier te gebruiken, moet u de structuur begrijpen, toegang krijgen tot elementen en gegevens efficiënt manipuleren in een tweedimensionaal raster. Bij het werken met gestructureerde gegevens of rasters kunnen 2D-arrays of lijsten nuttig zijn. Een 2D-array is in wezen een lijst met lijsten, die een tabelachtige structuur met rijen en kolommen vertegenwoordigt.
Een 1D-lijst maken
In Python vereist het initialiseren van een verzameling elementen in een lineaire reeks het creëren van een 1D-array, wat een fundamenteel proces is. Hoewel Python geen ingebouwde datastructuur heeft die een ‘1D-array’ wordt genoemd, kunnen we een lijst gebruiken die dezelfde functionaliteit kan bereiken. Python-lijsten zijn dynamisch en veelzijdig, waardoor ze een uitstekende keuze zijn voor het weergeven van 1D-arrays. Laten we beginnen met kijken naar veelgebruikte manieren om een 1d-array van grootte N te maken, geïnitialiseerd met 0s.
1D-lijst maken met behulp van naïeve methoden
Het handmatig initialiseren en vullen van een lijst zonder gebruik te maken van geavanceerde functies of constructies in Python staat bekend als het maken van een 1D-lijst met behulp van naïeve methoden.
Python3
N>=> 5> ar>=> [>0>]>*>N> print>(ar)> |
>
>
Uitvoer
[0, 0, 0, 0, 0]>
1D-lijst maken met behulp van Lijstbegrip
Hier vermenigvuldigen we het aantal rijen met de lege lijst en daarom wordt de hele lijst gemaakt met elk element nul.
Python3
N>=> 5> arr>=> [>0> for> i>in> range>(N)]> print>(arr)> |
>
>
Uitvoer
[0, 0, 0, 0, 0]>
Een 2D-lijst maken
Om 2D-arrays/lijsten op de juiste manier te gebruiken, moet u de structuur begrijpen, toegang krijgen tot elementen en gegevens efficiënt manipuleren in een tweedimensionaal raster. Door het gebruik van 2D-arrays onder de knie te krijgen, kunt u uw vermogen om met complexe gegevens om te gaan en verschillende bewerkingen efficiënt uit te voeren aanzienlijk verbeteren.
2D-lijst maken met behulp van Naïeve methode
Hier vermenigvuldigen we het aantal kolommen en zo krijgen we de 1D-lijst met een grootte die gelijk is aan het aantal kolommen en vermenigvuldigen we deze vervolgens met het aantal rijen, wat resulteert in het creëren van een 2D-lijst.
Python3
hoe u de weergavegrootte weet
rows, cols>=> (>5>,>5>)> arr>=> [[>0>]>*>cols]>*>rows> print>(arr)> |
>
>
Uitvoer
[[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]]>
Opmerking: Het gebruik van deze methode kan soms onverwacht gedrag veroorzaken. Bij deze methode verwijst elke rij naar dezelfde kolom. Dit betekent dat zelfs als we slechts één element van de array bijwerken, dezelfde kolom in onze array wordt bijgewerkt.
Python
rows, cols>=> (>5>,>5>)> arr>=> [[>0>]>*>cols]>*>rows> print>(arr,>'before'>)> arr[>0>][>0>]>=> 1> # update only one element> print>(arr,>'after'>)> |
>
>
Uitvoer
([[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-lijst maken met behulp van Lijstbegrip
Hier gebruiken we feitelijk het concept van lijstbegrip en passen we een lus toe voor een lijst binnen een lijst, waardoor we een 2D-lijst creëren.
Python3
rows, cols>=> (>5>,>5>)> arr>=> [[>0> for> i>in> range>(cols)]>for> j>in> range>(rows)]> print>(arr)> |
>
>
CSS-overgangsdekking
Uitvoer
[[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-lijst maken met behulp van Lege lijst
Hier voegen we nullen toe als elementen voor een aantal kolommen en voegen vervolgens deze 1D-lijst toe aan de lege rijlijst en creëren zo de 2D-lijst.
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)> |
>
>
Uitvoer
[[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]]>
Initialiseren van 2D-array
De meegeleverde code demonstreert twee verschillende benaderingen voor het initialiseren van een 2D-array in Python . Ten eerste de arrayarr>wordt geïnitialiseerd met behulp van een 2D-lijstbegrip, waarbij elke rij wordt gemaakt als[0, 0, 0, 0, 0]>. De gehele array wordt gemaakt als een lijst met verwijzingen naar dezelfde binnenlijst, wat resulteert in aliasing. Elke wijziging die aan een element in één rij wordt aangebracht, wordt in alle rijen weerspiegeld. De code toont vervolgens een andere benadering waarbij gebruik wordt gemaakt van een genest lijstbegrip om de 2D-array te makenarr>. Deze methode vermijdt aliasing door voor elke rij een nieuwe lijst te maken, wat resulteert in een goede 2D-array.
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)> |
>
>
Uitvoer
[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]>
Uitleg:
We verwachten dat alleen het eerste element van de eerste rij verandert in 1, maar het eerste element van elke rij wordt gewijzigd in 1 in methode 2a. Deze eigenaardige werking komt doordat Python oppervlakkige lijsten gebruikt die we zullen proberen te begrijpen.
In methode 1a maakt Python geen 5 integer-objecten, maar slechts één integer-object, en alle indices van de array arr wijzen naar hetzelfde int-object, zoals weergegeven.
Als we de 0e index toewijzen aan een ander geheel getal, bijvoorbeeld 1, dan wordt een nieuw geheel getalobject gemaakt met de waarde 1 en dan wijst de 0e index nu naar dit nieuwe int-object, zoals hieronder weergegeven
Op dezelfde manier breiden we, wanneer we een 2D-array maken als arr = [[0]*cols]*rows, in wezen de bovenstaande analogie uit.
- Er wordt slechts één geheel getalobject gemaakt.
- Er wordt een enkele 1d-lijst gemaakt en al zijn indices verwijzen naar hetzelfde int-object in punt 1.
- Nu, arr[0], arr[1], arr[2] …. arr[n-1] verwijzen allemaal naar hetzelfde lijstobject hierboven in punt 2.
De bovenstaande opstelling kan worden gevisualiseerd in de onderstaande afbeelding.
Laten we nu het eerste element in de eerste rij van arr wijzigen als arr[0][0] = 1
- arr[0] verwijst naar het enkele lijstobject dat we hierboven hebben gemaakt. (Onthoud dat arr[1], arr[2] ...arr[n-1] ook allemaal naar hetzelfde lijstobject verwijzen).
- De toewijzing van arr[0][0] zal een nieuw int-object creëren met de waarde 1 en arr[0][0] zal nu naar dit nieuwe int-object verwijzen. (en dat geldt ook voor arr[1][0], arr [2][0] … arr[n-1][0])
Dit is duidelijk te zien in onderstaande afbeelding.
Dus wanneer 2D-arrays op deze manier worden gemaakt, heeft het wijzigen van waarden in een bepaalde rij invloed op alle rijen, omdat er in wezen slechts één geheel getalobject en slechts één lijstobject is waarnaar wordt verwezen door alle rijen van de array.
Zoals je zou verwachten, is het moeilijk om fouten op te sporen die door dergelijk gebruik van ondiepe lijsten worden veroorzaakt. Daarom is de betere manier om een 2D-array te declareren
Python3
rows, cols>=> (>5>,>5>)> print>([[>0> for> i>in> range>(cols)]>for> j>in> range>(rows)])> |
>
>
Uitvoer
[[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]]>
Deze methode creëert 5 afzonderlijke lijstobjecten, in tegenstelling tot methode 2a. Eén manier om dit te controleren is door de operator ‘is’ te gebruiken, die controleert of de twee operanden naar hetzelfde object verwijzen.
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>])> |
>
>
Uitvoer
False True>