Module 11: bestanden lezen en schrijven

Inleiding

Eén van de belangrijkste toepassingen van Python voor dataverwerking is het lezen, wijzigen, en schrijven van tekstbestanden. Data wordt vaak opgeslagen in tekstbestanden, omdat dit soort bestanden gemakkelijk tussen verschillende programma’s overgedragen kan worden. Er zijn meerdere standaard bestandsformaten voor tekstbestanden, zoals “comma-separated values” (CSV) bestanden. Python ondersteunt een aantal van die formaten via modules, waarvan ik sommige later zal bespreken. Dit hoofdstuk focust op het openen, lezen, schrijven, en sluiten van willekeurige bestanden, ongeacht het formaat.

Platte tekstbestanden

“Tekstbestanden” of “platte tekstbestanden” zijn bestanden waarin alle tekens bedoeld zijn om te interpreteren als reguliere tekens, zoals je ze op een toetsenbord intypt. Bijvoorbeeld, Python programma’s zijn platte tekstbestanden, net als HTML bestanden. Tekstverwerkingsbestanden (zoals je bijvoorbeeld creëert met Word) zijn echter geen platte tekstbestanden, en plaatjes zijn dat ook niet. Als je wilt weten of een bestand een tekstbestand is, dan kun je het proberen te openen in een teksteditor (bijvoorbeeld IDLE). Als je dat doet en alleen leesbare tekst ziet, betreft het waarschijnlijk een tekstbestand. Anders wordt het een “binair bestand” genoemd (binaire bestanden worden besproken in hoofdstuk 19).

Tekstbestanden bestaan uit regels tekst. Aan het einde van iedere regel staat een “newline” symbool, in Python voorgesteld als het teken "\n". Verschillende besturingssystemen hebben verschillende manieren om dit teken op te slaan: sommige Windows programma’s slaan het op als “carriage return plus line feed” ("\r\n"), terwijl het bij Linux altijd wordt opgeslagen als een enkele "\n". Zolang je in Python een bestand benadert als een regulier tekstbestand, zal Python de tekens die het leest converteren naar de standaard "\n", en vice versa wanneer het tekens wegschrijft. Dus je hoeft je niet druk te maken om dit soort verschillen (behalve wanneer je bestanden kopieert naar andere besturingssystemen).

 

ASCII muis

Handles en pointers

Als je met een bestand werkt in een programma, moet je dat bestand openen. Het openen van een bestand creëert een zogeheten “handle” of “file handle.” Je kunt een handle zien als een variabele die toegang biedt tot een bestand. Een handle bevat een “pointer,” die een specifieke plaats in het bestand aanduidt. Die pointer wordt gebruikt als je leest uit het bestand of schrijft naar het bestand. Bijvoorbeeld, als je uit een bestand leest, begint het lezen daar waar de pointer wijst, en gedurende het lezen wordt de pointer verplaatst in het bestand.

Wanneer je een bestand opent, wordt de pointer op een specifiek punt in het bestand geplaatst, afhankelijk van de manier waarop het bestand geopend is. Als je het bestand opent alleen om eruit te lezen, dan staat de pointer aan het begin. Hetzelfde geldt als je het bestand opent voor zowel lezen als schrijven. Als je een bestand opent voor “appending” (dat wil zeggen, om nieuwe data toe te voegen aan het einde van het bestand), dan staat de pointer aan het einde. Tenslotte, als je het bestand opent voor alleen schrijven, dan wordt het bestand volledig leeg gemaakt en wordt de pointer geplaatst aan het begin van het, nu lege, bestand. Om een nieuw bestand te creëren (dat wil zeggen, een bestand met een naam die nog niet bestaat), open je het bestand voor alleen schrijven.

Na het openen van het bestand is de handle het enige toegangspunt tot het bestand. Alle acties die je uitvoert op het bestand, voer je uit met behulp van methodes van de handle.

Merk op dat er een restrictie bestaat binnen het besturingssysteem op het aantal bestanden dat tegelijkertijd geopend mag worden (hoewel deze restrictie over het algemeen erg hoog ligt). Het is daarom een goed idee om bestanden te sluiten als je ze niet langer nodig hebt.

Verplaatsing van de pointer

De pointer, die aangeeft waar je in het bestand bezig bent, wordt automatisch verplaatst. Bijvoorbeeld, als je 10 tekens uit het bestand wilt lezen, dan geeft de pointer aan welk de eerste van die 10 tekens is. Terwijl je leest, verplaatst de pointer zich 10 tekens, zodat de nieuwe pointer positie 10 tekens verder in het bestand is dan voordat de leesactie plaatsvond. Als je met tekstbestanden werkt, is deze automatische verplaatsing van de pointer precies wat je wilt. Er zijn methodes waarmee je de pointer handmatig kunt verplaatsen, maar zulke methodes worden over het algemeen alleen gebruikt bij binaire bestanden. In dit hoofdstuk zal ik daarom deze methodes niet bespreken, maar ik breng ze aan de orde in hoofdstuk 19.

Buffers

Als je wijzigingen maakt in bestanden, dan worden die vaak niet onmiddellijk in de betreffende bestanden opgeslagen. In plaats daarvan slaat het besturingssysteem de wijzigingen op in een buffer in het geheugen, en maakt de wijzigingen pas definitief in het bestand als dat nodig is (een praktijk die “flushing” wordt genoemd). Je kunt het definitief maken van de wijzigingen forceren door het bestand te sluiten. Bestanden worden ook automatisch gesloten als je je programma op een normale manier beëindigt – maar het is niet zo netjes om het sluiten niet expliciet in het programma te doen.

Als je programma crasht (bijvoorbeeld vanwege een runtime error), dan kan het gebeuren dat je wijzigingen niet allemaal zijn opgeslagen, en je bestanden daarom niet up-to-date zijn tot het moment dat de crash plaatsvond. Dus als je probeert een programma te debuggen kun je er niet van uitgaan dat de inhoud van de bestanden zo is als het programma ze gemaakt zou moeten te hebben.

Bestandsverwerking

De meeste programma’s die bestandsverwerking doen, volgen een proces dat, in een loop, de inhoud van een bestand leest, die inhoud op een of andere manier verwerkt, en tenslotte de bewerkte inhoud naar een ander bestand schrijft. Bijvoorbeeld, een programma kan regels uit een tekstbestand lezen, de woorden in iedere regel sorteren, en dan de gesorteerde woorden naar een ander bestand schrijven. Dit verschilt nauwelijks met een programma dat de gebruiker in een loop vraagt om een regel tekst, de woorden in de regel sorteert, en die woorden dan op het scherm toont met de print() functie. Ik heb gezien dat studenten het relatief gemakkelijk vinden om de versie van het programma te schrijven waarbij de gebruiker met het programma communiceert, maar het erg moeilijk vinden om een soortgelijk programma te schrijven dat informatie uit een bestand leest.

Ik ben er nooit achter gekomen waarom zoveel studenten bestandsverwerking zo lastig vinden, maar ik vermoed dat ze het gevoel hebben de controle over hun programma te verliezen als ze met bestanden werken. Als input handmatig verstrekt wordt, en output getoond wordt op het scherm, dan weet je min of meer welke regels code Python aan het uitvoeren is, en je kunt testen wat je wilt. Maar als je met bestanden werkt, dan moet je die bestanden van te voren klaarmaken, en dan het programma uitvoeren en wachten tot het klaar is voordat je de output bestanden kunt controleren.

Je hebt misschien het gevoel weinig controle over een bestandsverwerkend programma te hebben, maar tijdens het bouwen van het programma kun je altijd print() statements in je code opnemen om inzicht te krijgen in wat het programma doet. Bijvoorbeeld, wanneer je programma een regel uit een tekstbestand leest, kun je die regel printen, en als je programma een regel schrijft, kun je die ook printen. Op die manier is het inzicht dat je krijgt in de werkwijze van je programma nauwelijks anders dan wanneer je handmatige invoer aan je programma verstrekt.

Lezen van tekstbestanden

Om een tekstbestand te lezen, moet je het bestand eerst openen, dan de inhoud lezen, en tenslotte het bestand sluiten.

Openen van een bestand met open()

Om een bestand te openen, gebruik je de open() functie.

De open() functie krijgt twee argumenten, waarvan de tweede optioneel is. Het eerste argument is de naam van het bestand. Als het bestand niet in de huidige directory staat, moet je het complete pad naar het bestand opgeven zodat Python het kan vinden. Het tweede argument is de “modus.” Deze geeft aan hoe Python het bestand moet behandelen. De default modus (die gebruikt wordt als er geen argument wordt opgegeven) is dat het bestand wordt geopend als tekstbestand, en er alleen uit het bestand gelezen mag worden. Ik zal later bediscussiëren hoe je andere modi opgeeft.

De open() functie retourneert een handle, die je gebruikt voor alle andere functionaliteiten.

In plaats van <handle> = open( <bestandsnaam> ), schrijven Python programmeurs vaak open( <bestandsnaam> ) as <handle>. De tweede manier is equivalent met de eerste. Ikzelf prefereer de eerste manier, omdat deze het dichtst ligt bij de manieren waarop andere programmeertalen het openen van bestanden afhandelen. De tweede methode heeft echter een klein voordeel, dat ik zal bespreken wanneer ik het heb over het sluiten van bestanden.

Lezen uit een bestand met read()

De eenvoudigste manier om de inhoud van een bestand te lezen is via de read() methode, zonder argumenten, via de handle. Dit levert een string die de complete inhoud van het bestand bevat. read() kan een argument krijgen, dat ik zal bespreken in hoofdstuk 19, dat gaat over binaire bestanden.

Lezen uit een bestand verplaatst de pointer naar het teken dat volgt meteen na het laatste teken dat is gelezen. Dat betekent dat als je de read() methode aanroept zonder argumenten, de pointer verplaatst wordt naar het einde van het bestand (meteen achter het laatste teken in het bestand). Als je dan read() een tweede keer aanroept, valt er niks meer te lezen, omdat er niks staat na de pointer. read() retourneert dan een lege string.

Sluiten van een bestand met close()

Om een bestand te sluiten gebruik je de close() methode met de handle. Daarna is de handle niet meer gerelateerd aan het bestand. Ieder bestand dat je opent, moet je op enig moment weer sluiten in je programma.

Een compleet programma dat een bestand opent, de inhoud leest, de inhoud toont, en het bestand weer sluit, is dus het volgende:

fp = open( "pc_rose.txt" )
print( fp.read() )
fp.close()

Als alles wat je met het bestand wilt doen, gedaan kan worden in een enkel blok code, dan kun je dat blok als volgt schrijven:

with open( <bestandsnaam> ) as <handle>:
    <acties>

Deze syntactische constructie heeft als voordeel dat het bestand automatisch gesloten wordt als het blok <acties> eindigt, dus je hoeft niet expliciet de close() methode aan te roepen. Deze constructie is typisch Python; je ziet hem niet in veel andere programmeertalen.

Tonen van de inhoud van een bestand

Nu ik de eerste paar functies en methodes voor bestandsmanipulatie heb geïntroduceerd, kan ik code schrijven die de inhoud van een bestand leest.

with open( "pc_rose.txt" ) as fp:
    buffer = fp.read()
print( buffer )

Deze code verkeert in de veronderstelling dat een bestand met de naam “pc_rose.txt” beschikbaar is in dezelfde directory als waar het programma staat. Appendix 33 legt uit hoe je dit bestand kunt krijgen (als je het nog niet hebt). Als het bestand niet bestaat, krijg je een runtime error. Hoe je met zulke fouten om moet gaan wordt in het volgende hoofdstuk uitgelegd.

Wijzig in de code hierboven de bestandsnaam “pc_rose.txt” in een naam die niet bestaat. Bestudeer de fout die je krijgt als je het programma uitvoert.

Als je het bestand “pc_woodchuck.txt” hebt, wijzig dan de bestandsnaam in de code hierboven in die naam. Voer het programma uit en bestudeer de uitvoer.

Regels lezen met readline()

Om een tekstbestand regel voor regel te lezen, kun je de readline() methode gebruiken. Deze methode leest tekens uit het bestand, beginnend bij de pointer, tot aan en inclusief het volgende “newline” teken. Deze tekens worden als een string geretourneerd. Als je aan het einde van het bestand bent en je probeert een nieuwe regel te lezen, krijg je een lege string terug.

fp = open( "pc_rose.txt" )
while True:
    buffer = fp.readline()
    if buffer == "":
        break
    print( buffer )
fp.close()

Als je de code hierboven uitvoert, zul je zien dat er een lege regel wordt getoond tussen ieder van de regels die uit het bestand gelezen is. Waar komen die extra regels vandaan? Denk hierover na.

De extra regels zijn er omdat de readline() methode een string retourneert met de tekens die gelezen zijn, inclusief het newline teken. Dus als de buffer wordt afgedrukt, wordt ook het newline teken afgedrukt. En omdat de print() functie zelf ook naar een nieuwe regel gaat nadat hij is uitgevoerd, krijg je een lege regel te zien na iedere tekstregel die wordt afgedrukt.

Schrijf een programma dat regels leest uit “pc_rose.txt,” en alleen die regels toont die het woord "naam" bevatten.

Regels lezen met readlines()

Vergelijkbaar met de readline() methode is de readlines() methode. readlines() leest alle regels in een tekstbestand, en retourneert ze als een list van strings. De strings bevatten de newline tekens.

fp = open( "pc_rose.txt" )
buffer = fp.readlines()
for line in buffer:
    print( line, end="" )
fp.close()

Als je de code hierboven uitvoert, zie je niet de lege regels tussen de tekstregels. Dat komt omdat ik aan de aanroep van de print() functie het end="" argument heb toegevoegd, zodat print() niet zelf naar een nieuwe regel gaat na het afdrukken.

Wanneer gebruik je welke lees-methode?

De read() en de readlines() methodes lezen beide een bestand als geheel in. Dat is geen probleem voor relatief kleine bestanden, maar voor grote bestanden kan het gebeuren dat je onvoldoende geheugen beschikbaar hebt om de inhoud van de bestanden op een efficiënte manier vast te houden. In dit soort omstandigheden (of als je niet weet hoe groot een te lezen bestand is) moet je het tekstbestand regel voor regel lezen middels de readline() methode.

Het is vaak een goed idee om, gedurende het ontwikkelen van code, alleen de eerste paar regels van een tekstbestand te verwerken. Je beperkt dan de tijd die je programma nodig heeft om het bestand te verwerken, en je beperkt de hoeveelheid uitvoer die je moet bestuderen, wat debuggen vergemakkelijkt. Bijvoorbeeld, de code hieronder verwerkt slechts de eerste 5 regels van een bestand.

fp = open( "pc_jabberwocky.txt" )
teller = 0
while teller < 5:
    buffer = fp.readline()
    if buffer == "":
        break
    print( buffer, end="" )
    teller += 1
fp.close()

Als het programma klaar en foutvrij gemaakt is, kan ik de regeltellingen verwijderen en de loop wijzigen in while True, zodat het hele bestand verwerkt wordt.

Pas de code hierboven aan zodat je telt hoe vaak het woord “wauwelwok” (ongeacht gebruik van hoofd- of kleine letters) voorkomt in de eerste 5 regels. Druk alleen de telling af. Als het werkt, verwijder dan de regeltelling zodat je het programma uitvoert voor de tekst als geheel.

 

Schrijven in tekstbestanden

Het schrijven in een tekstbestand lijkt veel op het lezen uit een tekstbestand. Je opent het bestand, schrijft erin, en sluit het weer.

Openen voor schrijven

Om een bestand te openen voor schrijven, en voor schrijven alleen, geef je de waarde "w" mee als tweede argument aan de open() functie. Als het bestand nog niet bestaat, wordt het gecreëerd. Bestaat het wel, dan wordt het leeggemaakt.

Ik herhaal: als je een bestand opent voor schrijven en het bestand bestaat al, dan wordt de inhoud van het bestand zonder pardon weggegooid! Je zult geen waarschuwing krijgen die zegt “weet je het zeker?” Het bestand wordt gewoon leeggemaakt. Dus je moet heel erg voorzichtig zijn met het openen van een bestand voor schrijven. Gewoonlijk vraag ik studenten om hun programma’s zo te schrijven dat eerst gecontroleerd wordt of een bestand bestaat alvorens het voor schrijven wordt geopend, en als het bestaat, een foutmelding te geven. Functies om te controleren of een bestand bestaat volgen later in dit hoofdstuk.

Schrijven met write()

Om iets te schrijven naar een tekstbestand, gebruik je de write() methode met als argument een string die je wilt schrijven naar het bestand. De code hieronder vraagt je om een paar strings in te geven, en schrijft ze dan naar een bestand. Het programma stopt met het vragen om strings als je een lege string ingeeft. Aan het einde opent het programma het geschreven bestand, leest de inhoud, en toont die op het scherm. Voer deze code uit, geef op zijn minst twee strings in, en zie wat er gebeurt.

fp = open( "pc_writetest.tmp", "w" )
while True:
    tekst = input( "Geef een regel tekst: " )
    if tekst == "":
        break
    fp.write( tekst )
fp.close()

fp = open( "pc_writetest.tmp" )
buffer = fp.read()
fp.close()

print( buffer )

Als je hebt gedaan wat ik vroeg, zie je dat alle tekst die je hebt ingegeven in het bestand staat, maar dat alles op één lange regel staat. Er staan geen newline tekens in het bestand. De reden is dat je newline tekens expliciet moet schrijven als je ze in het bestand wilt hebben. Als je input van het toetsenbord leest via de input() functie, stop je weliswaar met input verstrekken door op Enter te drukken, maar dat heeft dan niet als resultaat dat er een newline teken in de ingegeven string staat. Dus je moet dat newline teken zelf toevoegen als je die nieuwe regels wilt zien.

Pas de code hierboven aan zodat er een newline teken in het bestand komt te staan na iedere ingegeven regel.

Schrijven met writelines()

Je kunt een list van strings in één keer naar een bestand schrijven, via de writelines() methode die de list als argument krijgt. Als je newline tekens tussen de strings wilt, moet je die expliciet opnemen aan het einde van iedere string in de list. writelines() is de tegenhanger van readlines(); als je de list die readlines() retourneert als argument voor writelines() gebruikt, zal de inhoud van het uitvoerbestand exact gelijk zijn aan de inhoud van het invoerbestand.

Er is geen writeline() methode. writeline() zou precies hetzelfde zijn als write(), dus hij is overbodig.

Oefening

Schrijf een programma dat de inhoud van “pc_rose.txt” leest, en exact dezelfde inhoud schrijft in een bestand “pc_writetest.tmp.” Open dan het bestand “pc_writetest.tmp” en toon de inhoud. Je kunt dit programma gemakkelijk bouwen door wat van de hierboven gegeven code bij elkaar te plakken.

Schrijf een programma dat de inhoud van “pc_rose.txt” leest, iedere regel achterstevoren zet, en dan de geïnverteerde regels wegschrijft naar het bestand “pc_writetest.tmp.” Open daarna “pc_writetest.tmp” en toon de inhoud.

Toevoegen aan tekstbestanden

“Toevoegen”(Engels: “appending”) houdt in dat er geschreven wordt aan het einde van een bestaand bestand. Als je een bestand opent om toe te voegen, wordt de inhoud niet verwijderd, maar wordt de pointer geplaatst aan het einde van het bestand, waar je dan nieuwe data mag wegschrijven. Om een bestand in deze modus te openen, gebruik je "a" als het tweede argument bij het openen van het bestand.

De code hieronder toont eerst de inhoud van “pc_writetest.tmp” (die nu zou moeten bestaan). Daarna wordt de gebruiker gevraagd om regels in te geven die aan het bestand worden toegevoegd. Tenslotte wordt de nieuwe inhoud van het bestand getoond. Ik heb dit programma iets beter gestructureerd dan ik hiervoor steeds deed, door gebruik van een constante voor de bestandsnaam en middels een functie voor het tonen van de bestandsinhoud.

NAAM = "pc_writetest.tmp"

def tooninhoud( bestandsnaam ):
    fp = open( bestandsnaam )
    print( fp.read() )
    fp.close()

tooninhoud( NAAM )

fp = open( NAAM, "a" )
while True:
    tekst = input( "Geef een regel tekst: " )
    if tekst == "":
        break
    fp.write( tekst+"\n" )
fp.close()

tooninhoud( NAAM )

os.path methodes

Je weet nu alles wat je moet weten om tekstbestanden in Python te manipuleren. Er zijn nog een aantal handige functies beschikbaar die het werken met bestanden vergemakkelijken. Deze vind je in de os.path module. Zoals gewoonlijk geef ik ze hier niet allemaal, maar ik noem wel de functies die je het meest zult gebruiken.

In deze functies refereert de term “pad” (Engels: “path”) aan een bestandsnaam of directory naam, compleet met het volledige pad vanaf de “root.” Zelfs als het pad niet volledig genoemd is, is het impliciet opgenomen aangezien ieder bestand op een specifieke plaats in het bestandssysteem te vinden is.

exists()

De functie exists() krijgt een pad als argument, en retourneert True als het pad bestaat, en anders False.

from os.path import exists

if exists( "pc_rose.txt" ):
    print( "pc_rose.txt bestaat" )
else:
    print( "pc_rose.txt bestaat niet" )

if exists( "pc_tulip.txt" ):
    print( "pc_tulip.txt bestaat" )
else:
    print( "pc_tulip.txt bestaat niet" )

isfile()

isfile() test of het pad dat als argument gegeven is een bestand is. Als het dat is, retourneert de functie True. Anders retourneert het False. Als het pad in het geheel niet bestaat, retourneert de functie ook False.

from os.path import isfile

if isfile( "pc_rose.txt" ):
    print( "pc_rose.txt is een bestand" )
else:
    print( "pc_rose.txt is geen bestand" )

isdir()

isfile() test of het pad dat als argument gegeven is een directory (folder) is. Als het dat is, retourneert de functie True. Anders retourneert het False. Als het pad in het geheel niet bestaat, retourneert de functie ook False.

from os.path import isdir

if isdir( "pc_rose.txt" ):
    print( "pc_rose.txt is een directory" )
else:
    print( "pc_rose.txt is geen directory" )

join()

join() krijgt één of meerdere delen van een pad mee als argument, en plakt die op een redelijk slimme manier aan elkaar om een geschikte naam voor een pad te vormen, die het retourneert. Dit betekent dat het “slashes” verwijdert of toevoegt waar nodig. join() is vooral handig in combinatie met listdir() (uitgelegd in hoofdstuk 16, en als voorbeeld gebruikt hieronder).

De reden dat join() handig is in combinatie met listdir(), is dat listdir() een list van bestandsnamen teruggeeft, waarbij de directory namen niet zijn opgenomen. Als je een list van bestandsnamen vraagt, wil je ze meestal op een of ander moment openen. Maar als je een bestand probeert te openen dat niet in de huidige directory staat, dan moet je het complete pad kennen. Als je listdir() uitvoert, geef je de directory mee als argument, dus je weet waar de bestanden zich bevinden. Om een compleet pad te bouwen, moet je dus die directory naam aan de naam van ieder bestand toevoegen. In plaats van zelf te beslissen waar je “slashes” moet zetten (en wat voor slashes het moeten zijn), kun je de samenstelling van het pad overlaten aan de join() functie.

De code hieronder zoekt alle bestanden in de huidige directory, en toont ze inclusief het complete pad. De code laat zien hoe je een padnaam bouwt middels join().

from os import listdir, getcwd
from os.path import join

bestandslist = listdir( "." )
for naam in bestandslist:
    pad = join( getcwd(), naam )
    print( pad )

basename()

basename() haalt de bestandsnaam uit een pad, en retourneert die.

from os.path import basename

print( basename( "/System/Home/readme.txt" ) )

dirname()

dirname() haalt de directory naam uit een pad, en retourneert die.

from os.path import dirname

print( dirname( "/System/Home/readme.txt" ) )

getsize()

getsize() krijgt een pad als argument, en retourneert de grootte van het betreffende bestand als een integer (die het aantal bytes weergeeft). Als het pad geen bestand is, krijg je een runtime error.

from os.path import getsize

num = getsize( "pc_rose.txt" )
print( num )

Schrijf een programma dat de groottes van alle bestanden in de huidige directory bij elkaar optelt, en het resultaat toont.

  • Het arrangement Module 11: bestanden lezen en schrijven is gemaakt met Wikiwijs van Kennisnet. Wikiwijs is hét onderwijsplatform waar je leermiddelen zoekt, maakt en deelt.

    Auteur
    Katleen Trio
    Laatst gewijzigd
    2025-03-14 15:57:18
    Licentie

    Dit lesmateriaal is gepubliceerd onder de Creative Commons Naamsvermelding-GelijkDelen 4.0 Internationale licentie. Dit houdt in dat je onder de voorwaarde van naamsvermelding en publicatie onder dezelfde licentie vrij bent om:

    • het werk te delen - te kopiëren, te verspreiden en door te geven via elk medium of bestandsformaat
    • het werk te bewerken - te remixen, te veranderen en afgeleide werken te maken
    • voor alle doeleinden, inclusief commerciële doeleinden.

    Meer informatie over de CC Naamsvermelding-GelijkDelen 4.0 Internationale licentie.

    Aanvullende informatie over dit lesmateriaal

    Van dit lesmateriaal is de volgende aanvullende informatie beschikbaar:

    Toelichting
    De basisvaardigheden van programmeren met Python.
    Eindgebruiker
    leerling/student
    Moeilijkheidsgraad
    gemiddeld

  • Downloaden

    Het volledige arrangement is in de onderstaande formaten te downloaden.

    Metadata

    LTI

    Leeromgevingen die gebruik maken van LTI kunnen Wikiwijs arrangementen en toetsen afspelen en resultaten terugkoppelen. Hiervoor moet de leeromgeving wel bij Wikiwijs aangemeld zijn. Wil je gebruik maken van de LTI koppeling? Meld je aan via info@wikiwijs.nl met het verzoek om een LTI koppeling aan te gaan.

    Maak je al gebruik van LTI? Gebruik dan de onderstaande Launch URL’s.

    Arrangement

    IMSCC package

    Wil je de Launch URL’s niet los kopiëren, maar in één keer downloaden? Download dan de IMSCC package.

    Voor developers

    Wikiwijs lesmateriaal kan worden gebruikt in een externe leeromgeving. Er kunnen koppelingen worden gemaakt en het lesmateriaal kan op verschillende manieren worden geëxporteerd. Meer informatie hierover kun je vinden op onze Developers Wiki.

  • Gebruik
    Weergave
  • Wikiwijs is een dienst van