Programmeren in Python (deel 4)

Invoer en uitvoer

In de vorige les gebruikten we de functies input en print voor invoer en uitvoer. In deze les gaan we hiermee verder en bespreken we allerlei manieren om de uitvoer aan te passen. Omdat we vaak de elementen uit een lijst of dictionary op een speciale manier willen tonen, gaan we ook nog dieper in op hoe je door de elementen van een lijst of dictionary loopt.

Koen Vervloesem

Wat leer je in deze les?

– De uitvoer van print aanpassen
– Flexibele uitvoer met str.format
– Lussen met for, list en dict comprehension
– Indexen en waardes tegelijk uit een lijst halen met enumerate
– Sleutels en waardes uit een dictionary halen met items, keys en values
– List comprehension
– Tekst uitlijnen en opvullen met str.format

In de vorige les gebruikte je de functie input om een getal aan de gebruiker te vragen en de functie print om uitvoer op het scherm te tonen. Die uitvoer bleef tot nu toe vrij elementair. Daarom bekijken we eerst allerlei mogelijkheden om de uitvoer aan te passen.

De uitvoer van print aanpassen

In de vorige les gebruikten we deze opdracht om een getal uit een dictionary op het scherm te tonen:

print(getallen[getal])

Maar wat als je meerdere objecten op dezelfde regel wilt tonen? Dat kan eenvoudig door meerdere objecten aan de functie print door te geven, gescheiden door een komma. Verander bijvoorbeeld de laatste regel in het laatste programma van vorige les door:

>>> print(getal, "is gelijk aan", getallen[getal])
1 is gelijk aan één

Alle objecten die je aan print doorgeeft, worden gescheiden door een spatie getoond.

Na de objecten die je aan de functie print doorgeeft, kun je nog argumenten toevoegen die de uitvoer van print veranderen, namelijk sep en end. Met sep (afkorting van separator) verander je de spatie tussen objecten door een andere afscheiding, en met end vervang je het einde van de uitvoer (standaard ‘\n’ waarmee je een newline of een nieuwe regel aanduidt) door iets anders. Bijvoorbeeld:

>>> print(getal, getallen[getal], sep = ': ', end = '\n\n')
1: één

>>>

Door aan het argument end twee newlines toe te kennen, komt er een lege regel na de uitvoer.

Plaatshouders

Als je meerdere objecten in één uitvoer met print wilt opnemen en/of complexere zaken aan de uitvoer wilt veranderen, komt de functie format van pas. In de eenvoudigste vorm pas je die functie toe op een string waarin je met {} plaats vrijhoudt. Het argument dat je aan de functie doorgeeft, komt op de plaats van die {}:

>>> 'Je hebt {} gekozen.'.format(1)
'Je hebt 1 gekozen.'

Dat werkt ook met meerdere plaatshouders:

>>> 'Je hebt {} gekozen tussen de getallen {} en {}.'.format(2, 1, 10)
'Je hebt 2 gekozen tussen de getallen 1 en 10.'

Je kunt de plaatshouders ook een volgnummer geven, zodat ze in een andere volgorde in de uitvoer komen dan de argumenten die je aan format doorgeeft:

>>> '{1} <= {0} <= {2}'.format(2, 1, 10)
'1 <= 2 <= 10'

Maar vaak is het duidelijker als je de argumenten een naam geeft en die namen ook in de plaatshouders gebruikt:

>>> '{min} <= {getal} <= {max}'.format(min=1, max=10, getal=2)
'1 <= 2 <= 10'

Door een lijst lopen met for

Vaak wil je niet één regel uitvoer tonen met print, maar meerdere, bijvoorbeeld voor alle elementen in een lijst of dictionary. We hebben dus een manier nodig om al die elementen af te gaan. Dat kan met een for-lus, zoals in het volgende programma:

namen = ['lies', 'jan', 'kees', 'mireille', 'koen', 'rob']

for naam in namen:
    print(naam)

Python gaat elk element uit de lijst met namen af en toont dit element met print. Als je zowel de index als de inhoud van elk element wilt tonen, maak je gebruik van de handige functie enumerate:

namen = ['lies', 'jan', 'kees', 'mireille', 'koen', 'rob']

for index, naam in enumerate(namen):
    print('{}: {}'.format(index, naam))

Door een dictionary lopen met for

We kunnen met een for-lus ook door alle elementen van een dictionary lopen. Afhankelijk van waarin je juist geïnteresseerd bent, kan dat op drie manieren. We tonen in het volgende programma achtereenvolgens hoe je door alleen de sleutels gaat, door alleen de waardes en door de sleutels met hun bijbehorende waardes:

scores = {'lies': 6231, 'bas': 2, 'kees': 18, 'mireille': 482, 'aniek': 35, 'bert': 184}

print('Spelers')
for speler in scores:
    print(speler)

print()
print('Scores')
for score in scores.values():
    print(score)

print()
print('Spelers met score')
for speler, score in scores.items():
    print('{}: {}'.format(speler, score))

De sleutels van een dictionary kun je ook opvragen met de functie keys, maar dat is hier niet nodig. Bijvoorbeeld:

scores.keys()

Tupels

In de for-lus waarmee we zowel de index als de waarde van alle elementen van een lijst doorlopen en de for-lus waarmee we zowel de sleutel als de waarde van alle elementen van een dictionary doorlopen zie je dat we twee elementen tegelijk na de for zetten: index, naam respectievelijk speler, score. Twee elementen met een komma ertussen vormen een speciaal datatype in Python: een tupel (tuple). Je kunt ook variabelen van het type tuple aanmaken, maar dat heb je normaal niet vaak nodig.

List comprehension

For-lussen zijn handig, maar voor complexere bewerkingen wat omslachtig. Stel dat we de lengte van de langste naam uit een lijst willen berekenen. Met een for-lus kunnen we dat als volgt doen:

namen = ['lies', 'jan', 'kees', 'mireille', 'koen', 'rob']

max_lengte = 0

for naam in namen:
    lengte = len(naam)
    if lengte > max_lengte:
        max_lengte = lengte

print(max_lengte)

Dit werkt en is vrij duidelijk, maar het kan beter. Voor dit soort bewerkingen heeft Python een handig concept: list comprehension. Daarmee kunnen we de hele voorgaande berekening vervangen door één regel:

namen = ['lies', 'jan', 'kees', 'mireille', 'koen', 'rob']

print(max([len(naam) for naam in namen]))

Deze regel zegt: voor elke naam in de lijst met namen bereken je de lengte van de naam, en daarvan bereken je het maximum. Het stuk [len(naam) for naam in namen] is een beknopte manier waarmee we een lijst aanmaken van de lengtes van alle elementen in de lijst namen.

Tekst uitlijnen en opvullen

Dan gaan we nu even terug naar de functie format. Daarmee kunnen we tekst uitlijnen, zowel links, rechts als gecentreerd, en lege ruimte opvullen met willekeurige tekens. Een voorbeeld:

>>> '{:=^15}'.format('Titel')
'=====Titel====='

En met iets als:

print('{naam:<6} : {score:0>6}'.format(naam='kees', score=3))

krijgen we als uitvoer:

kees   : 000003

Met ^ centreren we tekst, met < lijnen we tekst links uit en met > lijnen we tekst rechts uit. Na het uitlijningsteken komt het totaal aantal tekens dat de tekst maximum mag innemen. Vóór het uitlijningsteken kan nog optioneel een teken komen waarmee we lege ruimte opvullen. En als we de argumenten van format een naam geven, komt die naam vóór de dubbele punt.

Samenvatting

In deze les hebben we allerlei manieren gezien om de uitvoer van print aan te passen, zoals tekst uitlijnen en lege ruimte opvullen. We hebben ook gezien hoe je door de elementen van een lijst of dictionary loopt, zodat je die een voor een kunt tonen. Verder zijn we ook op list comprehension ingegaan, een krachtige manier om zonder lus berekeningen uit te voeren op alle elementen in een lijst of dictionary. In de volgende les gaan we het weer over invoer en uitvoer hebben, maar dan met bestanden. Bovendien kijken we ook hoe je foutmeldingen in je programma afvangt.

Opdracht 1

Neem de volgende dictionary met scores:

scores = {'lies': 6231, 'bas': 2, 'kees': 18, 'mireille': 482, 'aniek': 35, 'bert': 184}

Gebruik list comprehension om een lijst met tupels aan te maken waarvan elk tupel bestaat uit de naam met een hoofdletter en de score gedeeld door 100.

Opdracht 2

Neem de volgende dictionary met scores:

scores = {'lies': 6231, 'bas': 2, 'kees': 18, 'mireille': 482, 'aniek': 35, 'bert': 184}

Met alle kennis uit deze les kun je deze personen en hun scores in een tabel tonen, met als linkerkolom de namen en als rechterkolom de bijbehorende scores. De namen moeten links uitgelijnd zijn en de scores rechts met nullen vooraan. Je code moet met namen en scores van willekeurige lengte kunnen werken.

 

Uitwerking 1

>>> scores = {'lies': 6231, 'bas': 2, 'kees': 18, 'mireille': 482, 'aniek': 35, 'bert': 184}
>>> [(speler.capitalize(), score/100) for (speler, score) in scores.items()]
[('Lies', 62.31), ('Bas', 0.02), ('Kees', 0.18), ('Mireille', 4.82), ('Aniek', 0.35), ('Bert', 1.84)]

Met scores.items() krijgen we een lijst van tupels terug van de sleutels en waardes van de dictionary. Met list comprehension passen we in elk van deze tupels de sleutel en waarde zoals gevraagd aan.

 

Uitwerking 2

scores = {'lies': 6231, 'bas': 2, 'kees': 18, 'mireille': 482, 'aniek': 35, 'bert': 184}

max_naam = max([len(naam) for naam in scores])
max_getal = max([len(str(score)) for score in scores.values()])

for speler, score in scores.items():

    print('{speler:<{speler_breedte}}{score:0>{score_breedte}}'.format(speler=speler, speler_breedte=max_naam+3, score=score, score_breedte=max_getal))

Dit is een heel compact programma waarin alle kennis tot nu toe en van deze les bij elkaar komt. We berekenen eerst de maximumlengte van een naam door list comprehension toe te passen op de sleutels van de dictionary met scores. Daarna doen we hetzelfde voor de maximumlengte die we nodig hebben om de scores weer te geven.

Daarna lopen we door alle spelers en bijbehorende scores. We geven aan de functie format als argumenten de speler, de maximumlengte van de spelersnaam (waarbij we 3 optellen om de kolommen van elkaar te scheiden), de score en de maximumlengte van de score door. In de plaatshouder voor de speler geven we met < aan dat de naam van de speler links wordt uitgelijnd, en met {speler_breedte} daarna geven we aan hoeveel tekens lang de uitlijning dient te zijn. Daarna doen we hetzelfde voor de score, maar daar lijnen we rechts uit en vullen we de cijfers aan met nullen vooraan. Merk op dat alles in onze code wat begint met print op één lange regel komt.

 

Cheatsheet

for: een lus die voor alle elementen in een lijst of dictionary uitgevoerd wordt.

list comprehension: een beknopte manier om een lijst aan te maken.

newline: het teken \n waarmee je een nieuwe regel aanduidt.

tupel: een reeks objecten met een komma ertussen.