Een Python-lijstbegrip bestaat uit haakjes die de expressie bevatten, die voor elk element wordt uitgevoerd, samen met de for-lus om elk element in de Python-lijst te doorlopen.
Voorbeeld:
Python
numbers>=> [>12>,>13>,>14>,]> doubled>=> [x>*>2> for> x>in> numbers]> print>(doubled)> |
>
>
Uitvoer
[24, 26, 28]>
Syntaxis van Python-lijstbegrip
Syntaxis: nieuwe lijst = [ expressie(element) voor element in oudeLijst als voorwaarde ]
Parameter:
expressie: vertegenwoordigt de bewerking die u wilt uitvoeren op elk item binnen de iterabele. element: De term variabele verwijst naar elke waarde uit de iterabele. itereerbaar: geef de reeks elementen op die u wilt doorlopen (bijvoorbeeld een lijst, tupel of tekenreeks). condition: (Optioneel) Een filter helpt beslissen of een element al dan niet aan de nieuwe lijst moet worden toegevoegd.
Opbrengst: De retourwaarde van een lijstbegrip is een nieuwe lijst met de gewijzigde elementen die aan de gegeven criteria voldoen.
Het begrijpen van Python-lijsten biedt een veel kortere syntaxis voor het maken van een nieuwe lijst op basis van de waarden van een bestaande lijst.
Lijstbegrip in Python-voorbeeld
Hier is een voorbeeld van het gebruik van lijstbegrip om het kwadraat van het getal in Python te vinden.
Python
numbers>=> [>1>,>2>,>3>,>4>,>5>]> squared>=> [x>*>*> 2> for> x>in> numbers]> print>(squared)> |
>
>
Uitvoer
[1, 4, 9, 16, 25]>
Iteratie met lijstbegrip
In dit voorbeeld wijzen we 1, 2 en 3 toe aan de lijst en drukken we de lijst af met behulp van Lijstbegrip.
Python
# Using list comprehension to iterate through loop> List> => [character>for> character>in> [>1>,>2>,>3>]]> > # Displaying list> print>(>List>)> |
>
>
Uitvoer
[1, 2, 3]>
Maak zelfs een lijst met Lijstbegrip
In dit voorbeeld drukken we de even getallen van 0 tot 10 af met behulp van Lijstbegrip.
Python
list> => [i>for> i>in> range>(>11>)>if> i>%> 2> =>=> 0>]> print>(>list>)> |
>
>
Uitvoer
[0, 2, 4, 6, 8, 10]>
Matrix met behulp van lijstbegrip
In dit voorbeeld wijzen we gehele getallen 0 tot 2 tot 3 rijen van de matrix toe en drukken deze af met behulp van Lijstbegrip.
Python
matrix>=> [[j>for> j>in> range>(>3>)]>for> i>in> range>(>3>)]> > print>(matrix)> |
>
>
Uitvoer
[[0, 1, 2], [0, 1, 2], [0, 1, 2]]>
Lijstbegrippen versus For Loop
Er zijn verschillende manieren om door een lijst te bladeren. De meest gebruikelijke aanpak is echter het gebruik van de voor lus . Laten we naar het onderstaande voorbeeld kijken:
Python
# Empty list> List> => []> > # Traditional approach of iterating> for> character>in> 'Geeks 4 Geeks!'>:> >List>.append(character)> > # Display list> print>(>List>)> |
>
>
Uitvoer
['G', 'e', 'e', 'k', 's', ' ', '4', ' ', 'G', 'e', 'e', 'k', 's', '!']>
Hierboven ziet u de implementatie van de traditionele aanpak om door een lijst, string, tupel, enz. te itereren. Nu doet het begrijpen van lijsten in Python dezelfde taak en maakt het programma ook eenvoudiger.
Lijstbegrippen vertalen de traditionele iteratiebenadering met behulp van for loop in een eenvoudige formule, waardoor ze gemakkelijk te gebruiken zijn. Hieronder vindt u de aanpak voor het doorlopen van een lijst, tekenreeks, tuple, enz. met behulp van lijstbegrip in Python.
Python
# Using list comprehension to iterate through loop> List> => [character>for> character>in> 'Geeks 4 Geeks!'>]> > # Displaying list> print>(>List>)> |
>
>
Uitvoer
['G', 'e', 'e', 'k', 's', ' ', '4', ' ', 'G', 'e', 'e', 'k', 's', '!']>
Tijdanalyse in lijstbegrip en lus
De lijstbegrippen in Python zijn zowel computationeel als qua codeerruimte en -tijd efficiënter dan een for-loop. Meestal worden ze in één regel code geschreven. Het onderstaande programma geeft het verschil weer tussen loops en lijstbegrip op basis van prestaties.
Python
wat is een monitor
# Import required module> import> time> > > # define function to implement for loop> def> for_loop(n):> >result>=> []> >for> i>in> range>(n):> >result.append(i>*>*>2>)> >return> result> > > # define function to implement list comprehension> def> list_comprehension(n):> >return> [i>*>*>2> for> i>in> range>(n)]> > > # Driver Code> > # Calculate time taken by for_loop()> begin>=> time.time()> for_loop(>10>*>*>6>)> end>=> time.time()> > # Display time taken by for_loop()> print>(>'Time taken for_loop:'>,>round>(end>->begin,>2>))> > # Calculate time takens by list_comprehension()> begin>=> time.time()> list_comprehension(>10>*>*>6>)> end>=> time.time()> > # Display time taken by for_loop()> print>(>'Time taken for list_comprehension:'>,>round>(end>->begin,>2>))> |
>
>
Uitvoer
Time taken for_loop: 0.39 Time taken for list_comprehension: 0.35>
Uit het bovenstaande programma kunnen we zien dat het begrijpen van lijsten behoorlijk sneller gaat dan for loop.
Geneste lijstbegrippen
Geneste lijstbegrippen zijn niets anders dan een lijstbegrip binnen een ander lijstbegrip dat vrij gelijkaardig is aan geneste for-loops. Hieronder staat het programma dat geneste lus implementeert:
Python
matrix>=> []> > for> i>in> range>(>3>):> > ># Append an empty sublist inside the list> >matrix.append([])> > >for> j>in> range>(>5>):> >matrix[i].append(j)> > print>(matrix)> |
>
>
Uitvoer
[[0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4]]>
Door nu geneste lijstbegrippen te gebruiken, kan dezelfde uitvoer in minder regels code worden gegenereerd.
Python
# Nested list comprehension> matrix>=> [[j>for> j>in> range>(>5>)]>for> i>in> range>(>3>)]> > print>(matrix)> |
>
>
Uitvoer
[[0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4]]>
Maak een lijst van begrip en Lambda
Lambda-uitdrukkingen zijn niets anders dan verkorte weergaven van Python-functies. Het gebruik van lijstbegrippen met lambda zorgt voor een efficiënte combinatie. Laten we eens kijken naar de onderstaande voorbeelden:
In dit voorbeeld voegen we getallen van 10 tot en met 50 in de lijst in en drukken deze af.
Python
# using lambda to print table of 10> numbers>=> []> > for> i>in> range>(>1>,>6>):> >numbers.append(i>*>10>)> > print>(numbers)> |
>
>
Uitvoer
[10, 20, 30, 40, 50]>
Hier hebben we for loop gebruikt om een tabel van 10 af te drukken.
Python
numbers>=> [i>*>10> for> i>in> range>(>1>,>6>)]> > print>(numbers)> |
>
>
Uitvoer
[10, 20, 30, 40, 50]>
Hier hebben we alleen lijstbegrip gebruikt om een tabel van 10 weer te geven.
Python
# using lambda to print table of 10> numbers>=> list>(>map>(>lambda> i: i>*>10>, [i>for> i>in> range>(>1>,>6>)]))> > print>(numbers)> |
>
>
Uitvoer
[10, 20, 30, 40, 50]>
Ten slotte gebruiken we lambda + lijstbegrip om de tabel van 10 weer te geven. Deze combinatie is erg handig om efficiënte oplossingen in minder regels code te krijgen voor complexe problemen.
Voorwaardelijke bepalingen in het begrijpen van lijsten
We kunnen ook voorwaardelijke uitspraken toevoegen aan het lijstbegrip. We kunnen een lijst maken met behulp van bereik(), exploitanten , etc. en cal passen ook enkele voorwaarden toe op de lijst met behulp van de als verklaring .
Kernpunten
- Het begrijpen van de lijst is een effectief middel om lijsten te beschrijven en samen te stellen op basis van bestaande lijsten.
- Over het algemeen is het begrijpen van lijsten licht en eenvoudiger dan standaardfuncties en lussen voor lijstvorming.
- We moeten geen lange codes schrijven voor het begrijpen van lijsten om gebruiksvriendelijke code te garanderen.
- Elk begrip van de lijst kan in een for-lus worden herschreven, maar in de context van lijstinterpretatie kan niet elke for-lus worden herschreven.
Hieronder staan enkele voorbeelden die het gebruik van lijstbegrippen weergeven in plaats van de traditionele benadering van iteratie door middel van iterabel:
Begrip van Python-lijsten met If-else.
In het voorbeeld controleren we dat van 0 tot 7 als het getal even is en dan invoegen Even getal naar de lijst anders invoegen Oneven nummer naar de lijst.
Python
lis>=> [>'Even number'> if> i>%> 2> =>=> 0> >else> 'Odd number'> for> i>in> range>(>8>)]> print>(lis)> |
>
>
Uitvoer
['Even number', 'Odd number', 'Even number', 'Odd number', 'Even number', 'Odd number', 'Even number', 'Odd number']>
Geneste IF met lijstbegrip
In dit voorbeeld voegen we getallen in de lijst in die een veelvoud zijn van 10 tot 100, en drukken we deze af.
Python
lis>=> [num>for> num>in> range>(>100>)> >if> num>%> 5> =>=> 0> if> num>%> 10> =>=> 0>]> print>(lis)> |
hernoem een map linux
>
>
Uitvoer
[0, 10, 20, 30, 40, 50, 60, 70, 80, 90]>
Geef een vierkant met getallen van 1 tot en met 10 weer
In dit voorbeeld voegen we een vierkant van 1 tot 10 in in de lijst en drukken we de lijst af.
Python
# Getting square of number from 1 to 10> squares>=> [n>*>*>2> for> n>in> range>(>1>,>11>)]> > # Display square of even numbers> print>(squares)> |
>
>
Uitvoer
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]>
Geef transpositie van 2D-matrix weer
In dit voorbeeld maken we een transpositie van de matrix met behulp van lijstbegrip.
Python
een array van objecten java
# Assign matrix> twoDMatrix>=> [[>10>,>20>,>30>],> >[>40>,>50>,>60>],> >[>70>,>80>,>90>]]> > # Generate transpose> trans>=> [[i[j]>for> i>in> twoDMatrix]>for> j>in> range>(>len>(twoDMatrix[>0>]))]> > print>(trans)> |
>
>
Uitvoer
[[10, 40, 70], [20, 50, 80], [30, 60, 90]]>
Schakel tussen hoofdletters en kleine letters van elk teken in een string
In dit voorbeeld schakelen we het hoofdlettergebruik van elk teken in een bepaalde tekenreeks om met behulp van de XOR-operator met 32 en slaan we het resultaat op in een lijst.
Python
# Initializing string> string>=> 'Geeks4Geeks'> > # Toggle case of each character> List> => list>(>map>(>lambda> i:>chr>(>ord>(i) ^>32>), string))> > # Display list> print>(>List>)> |
>
>
Uitvoer
['g', 'E', 'E', 'K', 'S', 'x14', 'g', 'E', 'E', 'K', 'S']>
Keer elke snaar om in een tupel
In dit voorbeeld keren we strings om in een for-lus, voegen ze in de lijst in en drukken de lijst af.
Python
# Reverse each string in tuple> List> => [string[::>->1>]>for> string>in> (>'Geeks'>,>'for'>,>'Geeks'>)]> > # Display list> print>(>List>)> |
>
>
Uitvoer
['skeeG', 'rof', 'skeeG']>
Een lijst met Tupels maken uit twee afzonderlijke lijsten
In dit voorbeeld hebben we twee lijsten gemaakt van namen en leeftijden. Wij gebruiken zip() in het begrip van lijsten en we voegen de naam en leeftijd in als een tupel om op te sommen. Ten slotte drukken we de lijst met tupels af.
Python
names>=> [>'G'>,>'G'>,>'g'>]> ages>=> [>25>,>30>,>35>]> person_tuples>=> [(name, age)>for> name, age>in> zip>(names, ages)]> print>(person_tuples)> |
>
>
Uitgang:
[('G', 25), ('G', 30), ('g', 35)]> Geef de som van de cijfers van alle oneven elementen in een lijst weer.
In dit voorbeeld hebben we een lijst gemaakt en zoeken we de cijfersom van elk oneven element in de lijst.
Python
# Explicit function> def> digitSum(n):> >dsum>=> 0> >for> ele>in> str>(n):> >dsum>+>=> int>(ele)> >return> dsum> > > # Initializing list> List> => [>367>,>111>,>562>,>945>,>6726>,>873>]> > # Using the function on odd elements of the list> newList>=> [digitSum(i)>for> i>in> List> if> i &>1>]> > # Displaying new list> print>(newList)> |
>
>
Uitvoer
[16, 3, 18, 18]>
Voordelen van lijstbegrip
- Tijd- en ruimtebesparend dan lussen.
- Vereist minder regels code.
- Transformeert iteratieve instructie in een formule.
Begrijpingsoefeningen voor Python-lijsten
Hieronder staan twee oefenvragen over het begrijpen van Python-lijsten. We hebben de basiscode voor lijstbegrip besproken om de kubus van getallen te vinden, en code om de lengte van een woord te vinden met behulp van lijstbegrip en de len()-functie.
Q1. Kubus met getallen oefent vragen met behulp van lijstbegrip
Python
numbers>=> [>1>,>2>,>3>,>4>,>5>,>6>,>7>,>8>,>9>,>10>]> cube>=> [number>*>*>3> for> number>in> numbers]> print>(cube)> |
>
>
Uitvoer
[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]>
Vraag 2. Oefenvraag voor woordlengte vinden met behulp van lijstbegrip
Python
words>=> [>'apple'>,>'banana'>,>'cherry'>,>'orange'>]> word_lengths>=> [>len>(word)>for> word>in> words]> print>(word_lengths)> |
>
>
Uitvoer
[5, 6, 6, 6]>