Python for loop

De for-lus in Python is een iteratieve functie. Als je een sequentieel object hebt zoals een lijst, kun je de for-lus gebruiken om over de items in de lijst te itereren.

De functionaliteit van de for-lus verschilt niet veel van wat je ziet in meerdere andere programmeertalen.

In dit artikel zullen we de Python for-lus in detail verkennen en leren itereren over verschillende sequenties, waaronder lijsten, tuples en meer. Daarnaast zullen we leren om de doorloop van de lus te controleren met behulp van de break- en continue-statements.

Wanneer de for-lus te gebruiken

Altijd wanneer je een blok code een vast aantal keren moet herhalen. Als je het aantal keren dat het herhaald moet worden niet weet, gebruik dan in plaats daarvan een “while-lus”-verklaring.

Syntax van for-lus Python

De basissyntax van de for-lus in Python ziet er ongeveer zo uit als hieronder vermeld.

for itarator_variable in sequence_name:
	Statements
	. . .
	Statements

Syntaxe van de for-lus in Python in Detail

• Het eerste woord van de verklaring begint met het trefwoord “for”, wat het begin van de for-lus aangeeft.
• Vervolgens hebben we de iteratorvariabele die over de sequentie itereert en binnen de lus kan worden gebruikt om verschillende functies uit te voeren.
• Dan komt het “in” trefwoord in Python, dat de iteratorvariabele vertelt om te lussen voor elementen binnen de sequentie.
• En tot slot hebben we de sequentievariabele die een lijst, een tuple of een ander soort iterator kan zijn.
• De verklaringen die deel uitmaken van de lus zijn waar je kunt spelen met de iteratorvariabele en verschillende functies kunt uitvoeren

Druk individuele letters van een string af met behulp van de for-lus

Een Python-string is een reeks tekens. Als je binnen een van je programmeertoepassingen de tekens van een string afzonderlijk moet doorlopen, kun je hier de for-lus gebruiken.

Zo zou dat voor jou werken.

word="anaconda"
for letter in word:
	print (letter)

Uitvoer:

a
n
a
c
o
n
d
a

De reden waarom deze lus werkt is omdat Python een “string” beschouwt als een opeenvolging van tekens in plaats van naar de string als geheel te kijken.

Het gebruik van de for-lus om te itereren over een Python-lijst of tuple

Lijsten en Tuples zijn iterabele objecten. Laten we nu eens kijken hoe we over de elementen binnen deze objecten kunnen itereren.

words= ["Apple", "Banana", "Car", "Dolphin" ]
for word in words:
	print (word)

Uitvoer:

Apple
Banana
Car
Dolphin

Laten we nu verder gaan en werken aan het itereren over de elementen van een tuple hier.

nums = (1, 2, 3, 4)

sum_nums = 0

for num in nums:
    sum_nums = sum_nums + num

print(f'Sum of numbers is {sum_nums}')

# Uitvoer
# Som van de getallen is 10

Het nesten van Python for-lussen

Wanneer we een for-lus binnen een andere for-lus hebben, wordt dit een geneste for-lus genoemd. Er zijn meerdere toepassingen van een geneste for-lus.

Overweeg het bovenstaande lijstvoorbeeld. De for-lus print individuele woorden uit de lijst. Maar wat als we in plaats daarvan de afzonderlijke tekens van elk van de woorden binnen de lijst willen afdrukken?

Dit is waar een geneste for-lus beter werkt. De eerste lus (ouderlus) zal de woorden één voor één doorlopen. De tweede lus (kindlus) zal over de tekens van elk van de woorden lopen.

words= ["Apple", "Banana", "Car", "Dolphin" ]
for word in words:
        #Deze lus haalt het woord uit de lijst
        print ("The following lines will print each letters of "+word)
        for letter in word:
                #Deze lus haalt de letter voor het woord op
                print (letter)
        print("") #Deze print wordt gebruikt om een lege regel af te drukken

Uitvoer

A nested loop is structurally similar to nested if statements

Python for-lus met de range() functie

Python range is een van de ingebouwde functies. Wanneer je wilt dat de for-lus een specifiek aantal keren wordt uitgevoerd, of wanneer je een reeks objecten moet specificeren om af te drukken, werkt de range-functie erg goed.

Bij het werken met range(), kun je tussen 1 en 3 gehele getallen als argumenten doorgeven:

• start geeft de gehele waarde aan waarbij de reeks begint, als dit niet is opgenomen, begint start bij 0
• stop is altijd vereist en is het gehele getal waarnaar wordt geteld maar niet is opgenomen
• step bepaalt hoeveel de volgende iteratie moet worden verhoogd (of verlaagd in het geval van negatieve getallen), als dit wordt weggelaten, wordt step standaard ingesteld op 1

Bekijk het volgende voorbeeld waarbij ik de getallen 1, 2 en 3 wil afdrukken:

for x in range(3):
    print("Printing:", x)
	
# Uitvoer

# Afdrukken: 0
# Afdrukken: 1
# Afdrukken: 2

De range-functie accepteert ook een ander argument naast de start en de stop. Dit is het stap-argument. Het vertelt de range-functie hoeveel getallen over te slaan tussen elke telling.

In het onderstaande voorbeeld heb ik het getal 3 gebruikt als de stap en je kunt zien dat de uitvoergetallen het vorige getal + 3 zijn.

for n in range(1, 10, 3):
    print("Printing with step:", n)
	
# Uitvoer

# Afdrukken met stap: 1
# Afdrukken met stap: 4
# Afdrukken met stap: 7

We kunnen ook een negatieve waarde gebruiken voor ons step-argument om achteruit te itereren, maar we moeten onze start– en stop-argumenten dienovereenkomstig aanpassen:

for i in range(100,0,-10):
   print(i)

Hier is 100 de start-waarde, 0 is de stop-waarde, en -10 is het bereik, dus de lus begint bij 100 en eindigt bij 0, waarbij elke iteratie met 10 wordt verlaagd. Dit gebeurt in de uitvoer:

Output
100
90
80
70
60
50
40
30
20
10

Bij het programmeren in Python maken for-lussen vaak gebruik van het range()-sequentietype als parameters voor iteratie.

Onderbreekverklaring met for-lus

De break-verklaring wordt gebruikt om de for-lus voortijdig te verlaten. Het wordt gebruikt om de for-lus te onderbreken wanneer aan een specifieke voorwaarde is voldaan.

Laten we zeggen dat we een lijst met getallen hebben en willen controleren of een getal aanwezig is of niet. We kunnen over de lijst met getallen itereren en als het getal wordt gevonden, uit de lus breken omdat we niet hoeven door te gaan met itereren over de resterende elementen.

In dit geval zullen we de Python if else-voorwaarde gebruiken samen met onze for-lus.

nums = [1, 2, 3, 4, 5, 6]

n = 2

found = False
for num in nums:
    if n == num:
        found = True
        break

print(f'List contains {n}: {found}')

# Uitvoer
# Lijst bevat 2: True

De continue-verklaring met for-lus

We kunnen continue-verklaringen gebruiken binnen een for-lus om de uitvoering van het lichaam van de for-lus over te slaan voor een specifieke voorwaarde.

Laten we zeggen dat we een lijst van getallen hebben en we willen de som van positieve getallen afdrukken. We kunnen de continue-verklaringen gebruiken om de for-lus over te slaan voor negatieve getallen.

nums = [1, 2, -3, 4, -5, 6]

sum_positives = 0

for num in nums:
    if num < 0:
        continue
    sum_positives += num

print(f'Sum of Positive Numbers: {sum_positives}')

Python for-lus met een else-blok

We kunnen het else-blok gebruiken met een Python for-lus. Het else-blok wordt alleen uitgevoerd wanneer de for-lus niet wordt beëindigd door een break-verklaring.

Laten we zeggen dat we een functie hebben om de som van getallen af te drukken als en slechts als alle getallen even zijn.

We kunnen de break-verklaring gebruiken om de for-lus te beëindigen als er een oneven getal aanwezig is. We kunnen de som afdrukken in het else-deel zodat deze alleen wordt afgedrukt wanneer de for-lus normaal wordt uitgevoerd.

def print_sum_even_nums(even_nums):
    total = 0

    for x in even_nums:
        if x % 2 != 0:
            break

        total += x
    else:
        print("For loop executed normally")
        print(f'Sum of numbers {total}')


# dit zal de som afdrukken
print_sum_even_nums([2, 4, 6, 8])

# dit zal de som niet afdrukken vanwege een oneven getal in de reeks
print_sum_even_nums([2, 4, 5, 8])

# Uitvoer

# For-lus normaal uitgevoerd
# Som van getallen 20

For-lussen met sequentiële gegevenstypen

Lijsten en andere gegevenssequentietypen kunnen ook worden gebruikt als iteratieparameters in for-lussen. In plaats van door een range() te itereren, kunt u een lijst definiëren en door die lijst itereren.

We wijzen een lijst toe aan een variabele en itereren vervolgens door de lijst:

sharks = ['hammerhead', 'great white', 'dogfish', 'frilled', 'bullhead', 'requiem']

for shark in sharks:
   print(shark)

In dit geval printen we elk item in de lijst. Hoewel we de variabele shark hebben gebruikt, hadden we de variabele een andere geldige variabelenaam kunnen geven en zouden we dezelfde uitvoer krijgen:

Output
hammerhead
great white
dogfish
frilled
bullhead
requiem

De uitvoer hierboven toont aan dat de for-lus door de lijst is geïtereerd en elk item van de lijst per regel heeft afgedrukt.

Lijsten en andere op sequenties gebaseerde gegevenstypen zoals strings en tupels worden vaak gebruikt met lussen omdat ze iterabel zijn. U kunt deze gegevenstypen combineren met range() om items aan een lijst toe te voegen, bijvoorbeeld:

sharks = ['hammerhead', 'great white', 'dogfish', 'frilled', 'bullhead', 'requiem']

for item in range(len(sharks)):
   sharks.append('shark')

print(sharks)

Output
['hammerhead', 'great white', 'dogfish', 'frilled', 'bullhead', 'requiem', 'shark', 'shark', 'shark', 'shark', 'shark', 'shark']

Hier hebben we een placeholder-reeks van 'shark' toegevoegd voor elk item van de lengte van de lijst sharks.

U kunt ook een for-lus gebruiken om een lijst vanaf nul op te bouwen:

integers = []

for i in range(10):
   integers.append(i)

print(integers)

In dit voorbeeld wordt de lijst integers leeg geïnitialiseerd, maar de for-lus vult de lijst als volgt:

Output
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Vergelijkbaar kunnen we door strings itereren:

sammy = 'Sammy'

for letter in sammy:
   print(letter)

Output
S
a
m
m
y

Het itereren door tuples gebeurt in hetzelfde formaat als bij het itereren door lijsten of strings hierboven.

Bij het itereren door een dictionary is het belangrijk om de sleutel : waarde-structuur in gedachten te houden om ervoor te zorgen dat je het juiste element van de dictionary oproept. Hier is een voorbeeld dat zowel de sleutel als de waarde oproept:

sammy_shark = {'name': 'Sammy', 'animal': 'shark', 'color': 'blue', 'location': 'ocean'}

for key in sammy_shark:
   print(key + ': ' + sammy_shark[key])

Output
name: Sammy
animal: shark
location: ocean
color: blue

Bij het gebruik van dictionaries met for-lussen komt de iteratievariabele overeen met de sleutels van de dictionary, en dictionary_variable[iteratievariabele] komt overeen met de waarden. In het bovenstaande geval werd de iteratievariabele key gebruikt om voor de sleutel te staan, en sammy_shark[key] werd gebruikt om voor de waarden te staan.

Lussen worden vaak gebruikt om door te lopen en sequentiële datatypen te manipuleren.

Conclusie

De for-lus in Python lijkt erg op die van andere programmeertalen. We kunnen break- en continue-statements gebruiken met for-lussen om de uitvoering te wijzigen. Echter, in Python kunnen we ook een optioneel else-blok in een for-lus hebben.

I hope you have gained some interesting ideas from the tutorial above. If you have any questions, let us know in the comments below.

Vanaf hier kun je verder leren over lussen door tutorials te lezen over while-lussen en break-, continue- en pass-statements.

Om te werken met for-lussen in projecten, volg de volgende tutorials:

• Hoe je een Twitterbot maakt met Python 3 en de Tweepy-bibliotheek
• Hoe je werkt met taalgegevens in Python 3 met behulp van de Natural Language Toolkit NLTK
• Hoe je de woordfrequentie grafisch weergeeft met matplotlib in Python 3