Pytonorm tillhandahåller kraftfulla datastrukturer som kallas listor, som kan lagra och manipulera samlingar av element. Ger också många sätt att skapa 2-dimensionella listor/matriser. Men man måste känna till skillnaderna mellan dessa sätt eftersom de kan skapa komplikationer i kod som kan vara mycket svåra att spåra. I den här artikeln kommer vi att utforska det rätta sättet att använda 2D-matriser/listor i Python.
Använda 2D-matriser/listor på rätt sätt
Att använda 2D-matriser/listor på rätt sätt innebär att förstå strukturen, komma åt element och effektivt manipulera data i ett tvådimensionellt rutnät. När du arbetar med strukturerad data eller rutnät kan 2D-matriser eller listor vara användbara. En 2D-array är i huvudsak en lista med listor, som representerar en tabellliknande struktur med rader och kolumner.
Skapa en 1D-lista
I Python kräver initiering av en samling element i en linjär sekvens att skapa en 1D-array, vilket är en grundläggande process. Även om Python inte har en inbyggd datastruktur som kallas en '1D-array', kan vi använda en lista som kan uppnå samma funktionalitet. Python-listor är dynamiska och mångsidiga, vilket gör dem till ett utmärkt val för att representera 1D-matriser. Låt oss börja med att titta på vanliga sätt att skapa en 1d-array av storlek N initierad med nollor.
Skapa 1D-lista med naiva metoder
Att manuellt initiera och fylla i en lista utan att använda några avancerade funktioner eller konstruktioner i Python är känt som att skapa en 1D-lista med naiva metoder.
Python3
N>=> 5> ar>=> [>0>]>*>N> print>(ar)> |
>
>
Produktion
[0, 0, 0, 0, 0]>
Skapa 1D-lista med Listförståelse
Här multiplicerar vi antalet rader med den tomma listan och därför skapas hela listan med varje element noll.
Python3
N>=> 5> arr>=> [>0> for> i>in> range>(N)]> print>(arr)> |
>
>
Produktion
[0, 0, 0, 0, 0]>
Skapa en 2D-lista
Att använda 2D-matriser/listor på rätt sätt innebär att förstå strukturen, komma åt element och effektivt manipulera data i ett tvådimensionellt rutnät. Genom att behärska användningen av 2D-matriser kan du avsevärt förbättra din förmåga att hantera komplexa data och effektivt utföra olika operationer.
Skapa 2D-lista med hjälp av Naiv metod
Här multiplicerar vi antalet kolumner och därför får vi 1D-listan med storlek lika med antalet kolumner och multiplicerar den sedan med antalet rader vilket resulterar i skapandet av en 2D-lista.
Python3
rows, cols>=> (>5>,>5>)> arr>=> [[>0>]>*>cols]>*>rows> print>(arr)> |
>
>
Produktion
[[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]]>
Notera: Att använda den här metoden kan ibland orsaka oväntade beteenden. I den här metoden kommer varje rad att referera till samma kolumn. Detta innebär att även om vi bara uppdaterar ett element i arrayen kommer det att uppdatera samma kolumn i vår array.
Pytonorm
rows, cols>=> (>5>,>5>)> arr>=> [[>0>]>*>cols]>*>rows> print>(arr,>'before'>)> arr[>0>][>0>]>=> 1> # update only one element> print>(arr,>'after'>)> |
>
>
Produktion
hur man ändrar sträng till int
([[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')>
Skapa 1D-lista med hjälp av Listförståelse
Här använder vi i princip konceptet med listförståelse och tillämpar en loop för en lista inuti en lista och skapar därmed en 2D-lista.
Python3
rows, cols>=> (>5>,>5>)> arr>=> [[>0> for> i>in> range>(cols)]>for> j>in> range>(rows)]> print>(arr)> |
>
>
desc-tabell i mysql
Produktion
[[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]]>
Skapa 1D-lista med hjälp av Tom lista
Här lägger vi till nollor som element för ett antal kolumner gånger och lägger sedan till denna 1-D-lista i den tomma radlistan och skapar därmed 2-D-listan.
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)> |
>
>
Produktion
[[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]]>
Initierar 2D Array
Den medföljande koden visar två olika metoder för att initiera en 2D-array i Pytonorm . Först, arrayenarr>initieras med hjälp av en 2D-listförståelse, där varje rad skapas som[0, 0, 0, 0, 0]>. Hela arrayen skapas som en lista med referenser till samma inre lista, vilket resulterar i aliasing. Alla ändringar som görs av ett element i en rad kommer att återspeglas i alla rader. Koden visar sedan ett annat tillvägagångssätt som använder en kapslad listförståelse för att skapa 2D-matrisenarr>. Den här metoden undviker alias genom att skapa en ny lista för varje rad, vilket resulterar i en riktig 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)> |
>
>
Produktion
[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]>
Förklaring:
Vi förväntar oss att endast det första elementet i den första raden ändras till 1 men det första elementet i varje rad ändras till 1 i metod 2a. Denna märkliga funktion beror på att Python använder grunda listor som vi kommer att försöka förstå.
I metod 1a skapar Python inte 5 heltalsobjekt utan skapar bara ett heltalsobjekt, och alla index för arrayen pekar på samma int-objekt som visas.
Om vi tilldelar det 0:e indexet till ett annat heltal, säg 1, så skapas ett nytt heltalsobjekt med värdet 1 och sedan pekar det 0:e indexet på detta nya int-objekt som visas nedan
På liknande sätt, när vi skapar en 2d-array som arr = [[0]*cols]*rader, utökar vi i huvudsak ovanstående analogi.
- Endast ett heltalsobjekt skapas.
- En enda 1d-lista skapas och alla dess index pekar på samma int-objekt i punkt 1.
- Nu, arr[0], arr[1], arr[2] …. arr[n-1] pekar alla på samma listobjekt ovan i punkt 2.
Ovanstående inställning kan visualiseras i bilden nedan.
Låt oss nu ändra det första elementet i första raden av arr som arr[0][0] = 1
- arr[0] pekar på det enda listobjektet vi skapade ovan. (Kom ihåg att arr[1], arr[2] …arr[n-1] pekar alla på samma listobjekt också).
- Tilldelningen av arr[0][0] kommer att skapa ett nytt int-objekt med värdet 1 och arr[0][0] kommer nu att peka på detta nya int-objekt.(och så kommer arr[1][0], arr [2][0] … arr[n-1][0])
Detta kan tydligt ses på bilden nedan.
Så när 2d-arrayer skapas så här, kommer förändringar av värden på en viss rad att påverka alla rader eftersom det i huvudsak bara finns ett heltalsobjekt och endast ett listobjekt som refereras av alla rader i arrayen.
Som du kan förvänta dig är det svårt att spåra fel orsakade av sådan användning av ytliga listor. Därför är det bättre sättet att deklarera en 2d-array
Python3
rows, cols>=> (>5>,>5>)> print>([[>0> for> i>in> range>(cols)]>for> j>in> range>(rows)])> |
>
>
Produktion
[[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]]>
Denna metod skapar 5 separata listobjekt, till skillnad från metod 2a. Ett sätt att kontrollera detta är att använda operatorn 'is' som kontrollerar om de två operanderna refererar till samma objekt.
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>])> |
>
>
Produktion
False True>