En introduksjon
EN Liste regnes som en av de mest fleksible datastrukturene i programmeringsspråket Python. På den annen side er en todimensjonal liste, eller 2D-liste, som generelt kalles en liste over lister, et objekt av en liste der hvert element er en liste i seg selv. For eksempel: [[19, 18, 17], [16, 15, 14], [13, 12, 11]].
Å flate ut en liste over lister er en prosess for å transformere en to-dimensjonal liste til en en-dimensjonal liste ved å fjerne nesting av hvert listeelement som er i listen over lister, det vil si å transformere [[9, 8, 7], [6] , 5, 4], [3, 2, 1]] til [9, 8, 7, 6, 5, 4, 3, 2, 1].
Vi kan utføre utflatningsprosessen ved hjelp av nestede til løkker, rekursjon, listeforståelse, kjernefunksjoner eller import av bibliotekene eller pakkene i Python på dybden og regelmessigheten til de nestede listene.
I denne opplæringen skal vi trene på ulike metoder for å flate ut de nestede listene ved å bruke Python-programmeringsspråket. Men før vi begynner, la oss forstå typene Nested Lists.
Hva er typene nestede lister?
Som vi vet, Python er et svakt skrevet programmeringsspråk. Derfor kan vi støte på to typer liste over lister. Disse listene over lister eller nestede lister er som følger:
- Vanlig liste over lister
- Uregelmessig liste over lister
Vanlig liste over lister
Hvert element i den vanlige listen over lister blir referert til som en underliste, og observerer dermed enhetstypen til elementet. For eksempel: [[9, 8, 7], [6, 5, 4], [3, 2, 1]] er en vanlig liste over lister som [9, 8, 7], [6, 5, 4] , [3, 2, 1] er av listetypen.
Uregelmessig liste over lister
arrayliste metoder
Hvert element i den uregelmessige listen over lister blir enten referert til som en underliste eller et ikke-listeelement (for eksempel en streng eller et heltall). Dermed er det en uregelmessighet når det gjelder type element. For eksempel: [[9, 8, 7], [6, 5], 4, 3] er en uregelmessig liste over lister ettersom [9, 8, 7] og [6, 5] er av listetypene, mens 4 og 3 er av typen int.
Flatere listen over lister ved å bruke Nested for Loops
Flatere listen over lister med Nested til Loops' hjelp regnes som en brute force-tilnærming for å få en flat liste. Vi kan utføre denne metoden ved å velge hvert element fra den todimensjonale listen og ordne den i en endimensjonal liste.
La oss vurdere følgende eksempel som fungerer for både vanlige og uregelmessige lister.
Eksempel:
# 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))
Produksjon:
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]
Forklaring:
I eksemplet ovenfor har vi definert en funksjon som flatelist som tar inn en parameter som _2dlist . Vi har da brukt til løkke for å iterere elementene i den nestede listen og legge dem til for å generere en sammenslått liste. Vi har da definert den nestede listen og implementert flatelist funksjon. Som et resultat har den nestede listen transformert til den sammenslåtte listen.
Flate ut den nestede listen ved hjelp av en listeforståelse
Å flate ut listen over lister ved hjelp av en listeforståelse anses som en elegant tilnærming for å få en flat liste avhengig av en todimensjonal eksisterende liste. Denne tilnærmingen tilbyr imidlertid en mindre intuitiv løsning.
La oss vurdere følgende eksempel.
Eksempel:
# 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)
Produksjon:
Genuine list: [[10, 20, 30, 40], [50, 60, 70], [80, 90]] Converted list: [10, 20, 30, 40, 50, 60, 70, 80, 90]
Forklaring:
I eksemplet ovenfor har vi definert en nestet liste og listeforståelse. Vi har så skrevet dem ut for brukerne. Som et resultat har den nestede listen blitt transformert til den sammenslåtte listen.
Flate ut listen over lister ved hjelp av den rekursive metoden
Vi kan også bruke den rekursive metoden for å flate ut den todimensjonale listen. La oss vurdere følgende eksempel som implementerer den rekursive metoden for å flate ut listen over lister. Denne implementeringen fungerer bra for vanlige så vel som en uregelmessig liste over lister.
Eksempel:
# 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]))
Produksjon:
[10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
Forklaring:
I eksemplet ovenfor har vi definert en funksjon og brukt en hvis uttalelse angir om lengden på den nestede listen er lik null, returner den nestede listen.
strengformat java
Hvis dataelementet på den nullte indeksen er en forekomst av en liste, går listeindeksen inn i funksjonen igjen og legger til den følgende indeksen på listen og så videre. Ellers vil funksjonen returnere elementene og så videre. Til slutt har vi definert den nestede listen og utført funksjonen. Som et resultat har listen over lister flatet ut rekursivt.
Bruker Libraries of Python
Vi kan også bruke noen av Python-programmeringsspråkbibliotekene for å flate ut listen over lister. Implementeringen av disse bibliotekene er beskrevet nedenfor:
Flatere listen over lister ved hjelp av funksjonsverktøyene og operatørbibliotekene
De operatør biblioteket tilbyr iconcat() funksjon for å utføre den grunnleggende operasjonen som sammenkobling. Vi kan bruke denne funksjonen kumulativt på dataelementene i en nestet liste, fra venstre til høyre, noe som resulterer i reduksjon av den nestede listen til en sammenflatet liste.
La oss vurdere følgende eksempel for å forstå implementeringen.
Eksempel:
# 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, []))
Produksjon:
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]
Forklaring:
I eksemplet ovenfor har vi importert funksjonsverktøy bibliotek sammen med operatør bibliotek. Vi har da definert en tom liste som vanlig liste . Vi har da definert en funksjon som konvo for å transformere listen over lister til en sammenslått liste. I denne funksjonen har vi brukt til løkke der elementene fra den nestede listen legges til den tomme listen vi definerte tidligere. Senere har vi definert den nestede listen og utfører funksjonen. Som et resultat blir listen over lister konvertert til en sammenslått liste.
Flatere listen over lister ved hjelp av itertools-biblioteket
De itertools biblioteket tilbyr kjede() funksjon som lar oss transformere en nestet liste til en enkelt sammenslått liste ideelt sett. Denne funksjonen behandler påfølgende serier som en enkelt serie ved å iterere dem via den iterable som sendes som parameter på en seriell måte.
La oss vurdere følgende eksempel:
java-tupler
Eksempel:
# 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
Produksjon:
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]
Forklaring:
I eksemplet ovenfor har vi importert itertools bibliotek og genererte en nestet liste. Vi har da brukt kjede() funksjon for å konvertere den gitte nestede listen til den flate listen. Endelig har vi returnert resultatet til brukerne. Som et resultat blir listen over lister flatet ut.
Flatere listen over lister ved hjelp av NumPy-biblioteket
De NumPy biblioteket tilbyr forskjellige daglige operasjoner, inkludert sammenkobling av todimensjonale vanlige arrays kolonnevis eller radvis. Vi vil bruke attributtet kjent som flat for å få en endimensjonal iterator over arrayet for å erobre målet. La oss vurdere følgende eksempel for å forstå bruken av den sammenkoblede funksjonen og den flate attributten.
Eksempel:
# 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)
Produksjon:
The Nested list: [[10, 20, 30, 40], [50, 60, 70], [80, 90]] The Flattened list: [10, 20, 30, 40, 50, 60, 70, 80, 90]
Forklaring:
I eksemplet ovenfor har vi importert nusset bibliotek og definerte en nestet liste. Vi har da brukt sette sammen funksjonen til nusset bibliotek sammen med dens flat attributt for å flate ut elementene i den nestede listen og sette dem sammen til en ny sammenslått liste. Endelig har vi skrevet ut resultatet for brukerne. Dermed blir listen over lister flatet ut.
Bruke kjernefunksjoner
Vi kan også utføre utflatingsoppgaven ved å bruke noen kjernefunksjoner som programmeringsspråket Python gir.
Flate ut listen over lister ved å bruke sumfunksjonen
Vi kan vurdere å summere over indre lister som en annen løsning på problemet. Vi sender to argumenter til sum funksjon: Den første parameteren er gjentakelig , som er en nestet liste, og den andre parameteren er start som er en ugyldig liste for følgende tilfelle som fungerer som den første flate listen der dataelementene til de indre underlistene vil legges til.
Vi kan si at denne tilnærmingen er ganske praktisk siden vi ikke trenger å importere noe. Den er imidlertid tregere enn itertools() og kjede() fungerer når det er et stort antall underlister i den nestede listen.
java webtjenester
La oss vurdere følgende eksempel:
Eksempel:
# 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)
Produksjon:
The Nested list: [[10, 20, 30, 40], [50, 60, 70], [80, 90]] The Flattened list: [10, 20, 30, 40, 50, 60, 70, 80, 90]
Forklaring:
I eksemplet ovenfor har vi definert den nestede listen. Vi har da brukt sum() funksjon og flatet ut den nestede listen til en endimensjonal liste, og skrev ut den resulterende listen for brukerne. Som et resultat har vi forvandlet listen over lister til en flat liste.
Flatere listen over lister ved hjelp av Lambda-nøkkelord
Vi kan definere en anonym funksjon ved å bruke nøkkelordet lambda . Vi kan sende den vanlige/uregelmessige listen som parameter til denne anonyme funksjonen. Evalueringen av uttrykket gjøres for å få en flat endimensjonal liste.
La oss vurdere følgende eksempel:
Eksempel:
# 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))
Produksjon:
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]
Forklaring:
I eksemplet ovenfor har vi definert en nestet liste. Vi har da brukt lambda nøkkelord sammen med et argument som definerer et uttrykk for listeforståelse. Vi har så skrevet dem ut for brukerne. Som et resultat har vi konvertert den todimensjonale uregelmessige listen til den flate listen.