En introduktion
A Lista anses vara en av de mest flexibla datastrukturerna i programmeringsspråket Python. Å andra sidan är en tvådimensionell lista, eller 2D-lista, som allmänt kallas en lista med listor, ett objekt i en lista där varje element är en lista i sig. Till exempel: [[19, 18, 17], [16, 15, 14], [13, 12, 11]].
Att platta till en lista med listor är en process för att omvandla en tvådimensionell lista till en endimensionell lista genom att ta bort varje listelement som finns i listan med listor, det vill säga transformera [[9, 8, 7], [6] , 5, 4], [3, 2, 1]] till [9, 8, 7, 6, 5, 4, 3, 2, 1].
Vi kan utföra tillplattningsprocessen med hjälp av kapslingen för loopar, rekursion, listförståelse, kärnfunktioner eller import av biblioteken eller paketen i Python på djupet och regelbundenhet hos de kapslade listorna.
I den här handledningen kommer vi att träna på olika metoder för att platta till de kapslade listorna med hjälp av Python-programmeringsspråket. Men innan vi börjar, låt oss förstå vilka typer av kapslade listor.
Vilka typer av kapslade listor finns?
Som vi vet, Pytonorm är ett svagt skrivet programmeringsspråk. Därför kan vi stöta på två typer av listor. Dessa listor eller kapslade listor är följande:
- Vanlig lista med listor
- Oregelbunden lista över listor
Vanlig lista med listor
Varje post i den vanliga listan med listor hänvisas till som en underlista, och observerar således enhetligheten i typen av element. Till exempel: [[9, 8, 7], [6, 5, 4], [3, 2, 1]] är en vanlig lista med listor som [9, 8, 7], [6, 5, 4] , [3, 2, 1] är av listtypen.
Oregelbunden lista över listor
js settimeout
Varje objekt i den oregelbundna listan med listor kallas antingen för en underlista eller ett icke-listelement (till exempel en sträng eller ett heltal). Det finns alltså en oegentlighet när det gäller typen av element. Till exempel: [[9, 8, 7], [6, 5], 4, 3] är en oregelbunden lista med listor eftersom [9, 8, 7] och [6, 5] är av listtyperna, medan 4 och 3 är av typen int.
Platta ut listan med listor med Nested for Loops
Platta ut listan över listor med de kapslade för Loops hjälp anses vara en brute force-strategi för att få en platt lista. Vi kan utföra denna metod genom att välja varje objekt från den tvådimensionella listan och ordna den i en endimensionell lista.
Låt oss överväga följande exempel som fungerar för både vanliga och oregelbundna listor.
Exempel:
# defining the function def flattenlist(_2dlist): # defining an empty list flatlist = [] # Iterating through the outer list for item in _2dlist: if type(item) is list: # If the item is of the list type, iterating through the sub-list for element in item: flatlist.append(element) else: flatlist.append(item) return flatlist # defining the nested list nestedlist = [[10, 20, 30, 40], [50, 60, 70], [80, 90, 100]] print('Genuine List:', nestedlist) print('Converted Flat List:', flattenlist(nestedlist))
Produktion:
Genuine List: [[10, 20, 30, 40], [50, 60, 70], [80, 90, 100]] Converted Flat List: [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
Förklaring:
I exemplet ovan har vi definierat en funktion som platta list som tar in en parameter som _2dlist . Vi har då använt för loop för att iterera elementen i den kapslade listan och lägga till dem för att skapa en tillplattad lista. Vi har sedan definierat den kapslade listan och implementerat platta list fungera. Som ett resultat har den kapslade listan framgångsrikt omvandlats till den tillplattade listan.
Platta ut den kapslade listan med hjälp av en listförståelse
Att platta ut listan med listor med hjälp av en Listförståelse anses vara ett elegant tillvägagångssätt för att få en platt lista beroende på en tvådimensionell befintlig lista. Detta tillvägagångssätt erbjuder dock en mindre intuitiv lösning.
Låt oss överväga följande exempel.
Exempel:
# defining the nested list nestedlist = [[10, 20, 30, 40], [50, 60, 70], [80, 90]] # list comprehension flatlist = [element for sub_list in nestedlist for element in sub_list] print('Genuine list:', nestedlist) print('Converted list:', flatlist)
Produktion:
Genuine list: [[10, 20, 30, 40], [50, 60, 70], [80, 90]] Converted list: [10, 20, 30, 40, 50, 60, 70, 80, 90]
Förklaring:
I exemplet ovan har vi definierat en kapslad lista och listförståelse. Vi har sedan skrivit ut dem för användarna. Som ett resultat har den kapslade listan framgångsrikt omvandlats till den tillplattade listan.
Platta ut listan med listor med den rekursiva metoden
Vi kan också använda den rekursiva metoden för att platta ut den tvådimensionella listan. Låt oss överväga följande exempel som implementerar den rekursiva metoden för att förenkla listan med listor. Denna implementering fungerar bra för både vanliga och oregelbundna listor.
Exempel:
# defining a function def flattenlist(nestedlist): if len(nestedlist) == 0: return nestedlist if isinstance(nestedlist[0], list): return flattenlist(nestedlist[0]) + flattenlist(nestedlist[1:]) return nestedlist[:1] + flattenlist(nestedlist[1:]) print(flattenlist([[10, 20, 30, 40], [50, 60, 70], [80, 90], 100]))
Produktion:
[10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
Förklaring:
I exemplet ovan har vi definierat en funktion och använt en om påstående ange om längden på den kapslade listan är lika med noll, returnera sedan den kapslade listan.
strängformat java
Om dataelementet på det nollte indexet är en instans av en lista, går listindexet in i funktionen igen och läggs till följande index i listan och så vidare. Annars kommer funktionen att returnera elementen och så vidare. Äntligen har vi definierat den kapslade listan och utfört funktionen. Som ett resultat har listan med listor plattats ut rekursivt.
Använder Libraries of Python
Vi kan också använda några av Pythons programmeringsspråksbibliotek för att platta till listan med listor. Implementeringen av dessa bibliotek beskrivs nedan:
Förenkla listan med listor med hjälp av funktionsverktygen och operatörsbiblioteken
De operatör biblioteket tillhandahåller iconcat() funktion för att utföra den grundläggande operationen som sammanlänkning. Vi kan tillämpa denna funktion kumulativt på dataelementen i en kapslad lista, från vänster till höger, vilket resulterar i att den kapslade listan reduceras till en tillplattad lista.
Låt oss överväga följande exempel för att förstå dess genomförande.
Exempel:
# importing the required libraries import operator import functools regularlist = [] # Converting the list of lists into a flattened one. def convo(nestedlist): for element in nestedlist: if type(element) is list: regularlist.append(element) else: regularlist.append([element]) return regularlist twoDlist = [[10, 20, 30, 40], [50, 60, 70], [80, 90, 100], 110] regular2Dlist = convo(twoDlist) print('Given List:', twoDlist) print('Converted list:', functools.reduce(operator.iconcat, regular2Dlist, []))
Produktion:
Given List: [[10, 20, 30, 40], [50, 60, 70], [80, 90, 100], 110] Converted list: [10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110]
Förklaring:
I exemplet ovan har vi importerat funktionsverktyg biblioteket tillsammans med operatör bibliotek. Vi har sedan definierat en tom lista som ordinarie lista . Vi har då definierat en funktion som konvo för att omvandla listan med listor till en tillplattad lista. I den här funktionen har vi använt för loop där elementen från den kapslade listan läggs till den tomma listan som vi definierade tidigare. Senare har vi definierat den kapslade listan och kör funktionen. Som ett resultat konverteras listan med listor till en tillplattad lista.
Platta ut listan med listor med itertools-biblioteket
De itertools biblioteket tillhandahåller kedja() funktion som låter oss omvandla en kapslad lista till en enda tillplattad lista idealiskt. Denna funktion behandlar på varandra följande serier som en enda serie genom att iterera dem via den iterable som skickas som parameter på ett seriellt sätt.
Låt oss överväga följande exempel:
metodöverbelastning
Exempel:
# importing the itertools library import itertools # defining the nested list nestedlist = [[10, 20, 30, 40], [50, 60, 70], [80, 90, 100]] flattenlist = list(itertools.chain(*nestedlist)) print('The nested list:', nestedlist) print('The flattened list:', flattenlist
Produktion:
The nested list: [[10, 20, 30, 40], [50, 60, 70], [80, 90, 100]] The flattened list: [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
Förklaring:
I exemplet ovan har vi importerat itertools bibliotek och genererade en kapslad lista. Vi har då använt kedja() funktion för att konvertera den givna kapslade listan till den tillplattade listan. Äntligen har vi lämnat tillbaka resultatet till användarna. Som ett resultat blir listan med listor tillplattad.
Platta ut listan med listor med hjälp av NumPy-biblioteket
De NumPy biblioteket tillhandahåller olika vardagliga operationer, inklusive sammanlänkning av tvådimensionella vanliga arrayer kolumnvis eller radvis. Vi kommer att använda attributet som kallas platt för att få en endimensionell iterator över arrayen för att erövra målet. Låt oss överväga följande exempel för att förstå användningen av konkateneringsfunktionen och det platta attributet.
Exempel:
# importing the library import numpy # defining the nested list nestedlist = [[10, 20, 30, 40], [50, 60, 70], [80, 90]] # using the concatenate function along with the flat attribute flattenlist = list(numpy.concatenate(nestedlist).flat) print('The Nested list:', nestedlist) print('The Flattened list:', flattenlist)
Produktion:
The Nested list: [[10, 20, 30, 40], [50, 60, 70], [80, 90]] The Flattened list: [10, 20, 30, 40, 50, 60, 70, 80, 90]
Förklaring:
I exemplet ovan har vi importerat numpy bibliotek och definierade en kapslad lista. Vi har då använt sammanfoga funktion av numpy bibliotek tillsammans med dess platt attribut för att platta till elementen i den kapslade listan och sammanfoga dem till en ny tillplattad lista. Äntligen har vi skrivit ut resultatet för användarna. Listan med listor plattas således ut framgångsrikt.
Använder kärnfunktioner
Vi kan också utföra plattningsuppgiften genom att använda några kärnfunktioner som Python-programmeringsspråket tillhandahåller.
Platta ut listan med listor med hjälp av summafunktionen
Vi kan överväga att summera inre listor som en annan lösning på problemet. Vi skickar två argument till belopp funktion: Den första parametern är iterabel , som är en kapslad lista, och den andra parametern är Start vilket är en ogiltig lista för följande fall som fungerar som den initiala platta listan där dataelementen i de inre underlistorna kommer att läggas till.
Vi kan säga att detta tillvägagångssätt är ganska bekvämt eftersom vi inte behöver importera något. Det är dock långsammare än itertools() och kedja() fungerar när det finns ett stort antal underlistor i den kapslade listan.
Låt oss överväga följande exempel:
Exempel:
# defining a nested list nestedlist = [[10, 20, 30, 40], [50, 60, 70], [80, 90]] # using the sum function flattenlist = sum(nestedlist, []) print('The Nested list:', nestedlist) print('The Flattened list:', flattenlist)
Produktion:
The Nested list: [[10, 20, 30, 40], [50, 60, 70], [80, 90]] The Flattened list: [10, 20, 30, 40, 50, 60, 70, 80, 90]
Förklaring:
sträng till json-objekt
I exemplet ovan har vi definierat den kapslade listan. Vi har då använt belopp() funktion och plattade den kapslade listan till en endimensionell lista och skrev ut den resulterande listan för användarna. Som ett resultat har vi framgångsrikt omvandlat listan med listor till en platt lista.
Platta ut listan med listor med Lambda nyckelord
Vi kan definiera en anonym funktion med nyckelordet lambda . Vi kan skicka den vanliga/oregelbundna listan som parameter till denna anonyma funktion. Utvärderingen av uttrycket görs för att få en platt endimensionell lista.
Låt oss överväga följande exempel:
Exempel:
# Defining the nested list nestedlist = [[10, 20, 30], [30, 50, 60], [40, 60, 70], 70] # Using lambda parameters: expression flattenlist = lambda nestedlist:[item for element in nestedlist for item in flattenlist(element)] if type(nestedlist) is list else [nestedlist] print('The Nested list:', nestedlist) print('The Flattened List:', flattenlist(nestedlist))
Produktion:
The Nested list: [[10, 20, 30], [30, 50, 60], [40, 60, 70], 70] The Flattened List: [10, 20, 30, 30, 50, 60, 40, 60, 70, 70]
Förklaring:
I exemplet ovan har vi definierat en kapslad lista. Vi har då använt lambda nyckelord tillsammans med ett argument som definierar ett uttryck för listförståelse. Vi har sedan skrivit ut dem för användarna. Som ett resultat har vi framgångsrikt konverterat den tvådimensionella oregelbundna listan till den tillplattade listan.