Keywords zijn de gereserveerde woorden in Python. We kunnen een keyword niet gebruiken als variabele naam, functie naam of een andere identifier.

Hier vindt u een lijst van alle sleutelwoorden in Python Programmeren

De bovenstaande sleutelwoorden kunnen gewijzigd worden in verschillende versies van Python. Sommige kunnen worden toegevoegd of sommige kunnen worden verwijderd. U kunt altijd de lijst van trefwoorden in uw huidige versie krijgen door het volgende in de prompt te typen.

>>> import keyword>>> print(keyword.kwlist)

Beschrijving van trefwoorden in Python met voorbeelden

True, False

True en False zijn waarheidswaarden in Python. Het zijn de resultaten van vergelijkingsoperaties of logische (Booleaanse) bewerkingen in Python. Bijvoorbeeld:

>>> 1 == 1True>>> 5 > 3True>>> True or FalseTrue>>> 10 <= 1False>>> 3 > 7False>>> True and FalseFalse

Hier zien we dat de eerste drie beweringen waar zijn, dus de interpreter geeft True terug en geeft False terug voor de overige drie beweringen. True en False in python is hetzelfde als 1 en 0. Dit kan worden gerechtvaardigd met het volgende voorbeeld:

>>> True == 1True>>> False == 0True>>> True + True2

None

None is een speciale constante in Python die de afwezigheid van een waarde of een null-waarde vertegenwoordigt.

Het is een object van zijn eigen datatype, de NoneType. We kunnen niet meerdere None objecten maken, maar we kunnen het wel toewijzen aan variabelen. Deze variabelen zullen aan elkaar gelijk zijn.

We moeten er speciaal op letten dat None niet False, 0 of een lege lijst, woordenboek, string enz. impliceert. Bijvoorbeeld:

>>> None == 0False>>> None == False>>> None == FalseFalse>>> x = None>>> y = None>>> x == yTrue

Void functies die niets teruggeven zullen automatisch een None object teruggeven. None wordt ook geretourneerd door functies waarin de programma flow geen return statement tegenkomt. Bijvoorbeeld:

def a_void_function(): a = 1 b = 2 c = a + bx = a_void_function()print(x)

Output

None

Dit programma heeft een functie die geen waarde teruggeeft, hoewel het een aantal bewerkingen binnenin uitvoert. Dus als we x afdrukken, krijgen we None die automatisch (impliciet) wordt geretourneerd. Evenzo is hier een ander voorbeeld:

def improper_return_function(a): if (a % 2) == 0: return Truex = improper_return_function(3)print(x)

Output

None

Hoewel deze functie een return statement heeft, wordt het niet in alle gevallen bereikt. De functie geeft True alleen terug als de invoer even is.

Als we de functie een oneven getal geven, wordt None impliciet teruggegeven.

en, of , niet

and, or, not zijn de logische operatoren in Python. and resulteert alleen in True als beide operanden True zijn. De waarheidstabel voor and is hieronder gegeven:

or zal resulteren in True als een van de operanden True is. De waarheidstabel voor or is hieronder gegeven:

not operator wordt gebruikt om de waarheidswaarde te inverteren. De waarheidstabel voor not is hieronder gegeven:

sommige voorbeelden van hun gebruik worden hieronder gegeven

>>> True and FalseFalse>>> True or FalseTrue>>> not FalseTrue

as

as wordt gebruikt om een alias te maken tijdens het importeren van een module. Het betekent een andere naam (door de gebruiker gedefinieerd) geven aan een module tijdens het importeren ervan.

Zo heeft Python bijvoorbeeld een standaardmodule die math heet. Stel dat we willen berekenen wat cosinus pi is met behulp van een alias. Dat kunnen we als volgt doen met as:

>>> import math as myAlias>>>myAlias.cos(myAlias.pi)-1.0

Hier hebben we de module math geïmporteerd door hem de naam myAlias te geven. Nu kunnen we naar de math module verwijzen met deze naam. Met deze naam hebben we cos(pi) berekend en -1.0 als antwoord gekregen.

assert

assert wordt gebruikt voor debugging-doeleinden.

Tijdens het programmeren willen we soms de interne toestand weten of controleren of onze aannames waar zijn. assert helpt ons dit te doen en bugs eenvoudiger te vinden. assert wordt gevolgd door een voorwaarde.

Als de voorwaarde waar is, gebeurt er niets. Maar als de voorwaarde onwaar is, wordt AssertionError opgewekt. Bijvoorbeeld:

>>> a = 4>>> assert a < 5>>> assert a > 5Traceback (most recent call last): File "<string>", line 301, in runcode File "<interactive input>", line 1, in <module>AssertionError

Voor ons beter begrip, kunnen we ook een boodschap meegeven die met de AssertionError wordt afgedrukt.

>>> a = 4>>> assert a > 5, "The value of a is too small"Traceback (most recent call last): File "<string>", line 301, in runcode File "<interactive input>", line 1, in <module>AssertionError: The value of a is too small

Op dit punt kunnen we opmerken dat,

assert condition, message

gelijk is aan,

if not condition: raise AssertionError(message)

async, await

De async en await sleutelwoorden worden geleverd door de asyncio bibliotheek in Python. Ze worden gebruikt om gelijktijdige code in Python te schrijven. Bijvoorbeeld,

import asyncioasync def main(): print('Hello') await asyncio.sleep(1) print('world')

Om het programma uit te voeren, gebruiken we

asyncio.run(main())

In het bovenstaande programma, specificeert het async sleutelwoord dat de functie asynchroon zal worden uitgevoerd.

Hier wordt eerst Hello afgedrukt. Het await sleutelwoord zorgt ervoor dat het programma 1 seconde wacht. En dan wordt de wereld afgedrukt.

break, continue

break en continue worden gebruikt binnen for en while lussen om hun normale gedrag te veranderen.

break beëindigt de kleinste lus waarin het zich bevindt en de controle gaat naar het statement direct onder de lus. continue zorgt ervoor dat de huidige iteratie van de lus wordt beëindigd, maar niet de hele lus.

Dit kan worden geïllustreerd met de volgende twee voorbeelden:

for i in range(1,11): if i == 5: break print(i)

Output

1234

Hier is de for lus van plan om getallen van 1 tot 10 af te drukken. Maar aan de if voorwaarde is voldaan wanneer i gelijk is aan 5 en we breken de lus af. Dus, alleen het bereik 1 tot 4 wordt afgedrukt.

for i in range(1,11): if i == 5: continue print(i)

Output

1234678910

Hier gebruiken we continue voor hetzelfde programma. Dus, als aan de voorwaarde is voldaan, wordt die iteratie overgeslagen. Maar we sluiten de lus niet af. Daarom worden alle waarden behalve 5 afgedrukt.

Lees meer over Python break en continue statement.

class

class wordt gebruikt om een nieuwe door de gebruiker gedefinieerde klasse in Python te definiëren.

Klasse is een verzameling verwante attributen en methoden die een real-world situatie proberen weer te geven. Dit idee van het samenvoegen van gegevens en functies in een klasse staat centraal in het concept van object-georiënteerd programmeren (OOP).

Klassen kunnen overal in een programma worden gedefinieerd. Maar het is een goed gebruik om een enkele klasse in een module te definiëren. Hieronder volgt een voorbeeldgebruik:

class ExampleClass: def function1(parameters): … def function2(parameters): …

Lees meer over Python-objecten en klassen.

def

def wordt gebruikt om een door de gebruiker gedefinieerde functie te definiëren.

Functie is een blok van verwante verklaringen, die samen een specifieke taak uitvoeren. Het helpt ons om code in hanteerbare brokken te organiseren en ook om sommige herhaalde taken uit te voeren.

Het gebruik van def wordt hieronder getoond:

def function_name(parameters): …

Lees meer over Python functies.

del

del wordt gebruikt om de verwijzing naar een object te verwijderen. Alles is een object in Python. We kunnen een verwijzing naar een variabele verwijderen met del

>>> a = b = 5>>> del a>>> aTraceback (most recent call last): File "<string>", line 301, in runcode File "<interactive input>", line 1, in <module>NameError: name 'a' is not defined>>> b5

Hier kunnen we zien dat de verwijzing van de variabele a is verwijderd. Dus, het is niet langer gedefinieerd. Maar b bestaat nog steeds.

del wordt ook gebruikt om items uit een lijst of een woordenboek te verwijderen:

>>> a = >>> del a>>> a

if, else, elif

if, else, elif worden gebruikt voor voorwaardelijke vertakkingen of besluitvorming.

Wanneer we een voorwaarde willen testen en een blok alleen willen uitvoeren als de voorwaarde waar is, dan gebruiken we if en elif. elif is de afkorting van else if. else is het blok dat wordt uitgevoerd als de voorwaarde onwaar is. Dit zal duidelijk worden met het volgende voorbeeld:

def if_example(a): if a == 1: print('One') elif a == 2: print('Two') else: print('Something else')if_example(2)if_example(4)if_example(1)

Output

TwoSomething elseOne

Hier controleert de functie het ingevoerde getal en drukt het resultaat af als het 1 of 2 is. Elke invoer anders dan dit zal het else deel van de code laten uitvoeren.

Lees meer over Python if en if…else Statement.

except, raise, try

except, raise, try worden gebruikt met uitzonderingen in Python.

Excepties zijn in feite fouten die suggereren dat er iets fout is gegaan tijdens het uitvoeren van ons programma. IOError, ValueError, ZeroDivisionError, ImportError, NameError, TypeError enz. zijn enkele voorbeelden van uitzonderingen in Python. try...except blokken worden gebruikt om uitzonderingen op te vangen in Python.

We kunnen een uitzondering expliciet oproepen met het raise sleutelwoord. Hier volgt een voorbeeld:

def reciprocal(num): try: r = 1/num except: print('Exception caught') return return rprint(reciprocal(10))print(reciprocal(0))

Uitvoer

0.1Exception caughtNone

Hier geeft de functie reciprocal() de reciproke van het ingevoerde getal.

Wanneer we 10 invoeren, krijgen we de normale uitvoer van 0,1. Maar als we 0 invoeren, wordt automatisch een ZeroDivisionError opgewekt.

Dit wordt opgevangen door ons try…except blok en we geven None terug. We hadden de ZeroDivisionError ook expliciet kunnen oproepen door de invoer te controleren en het elders als volgt af te handelen:

if num == 0: raise ZeroDivisionError('cannot divide')

finaal

finally wordt gebruikt met try…except blok om bronnen of bestandsstromen af te sluiten.

Het gebruik van finally zorgt ervoor dat het blok code erin wordt uitgevoerd, zelfs als er een niet-afgehandelde uitzondering is. Bijvoorbeeld:

try: Try-blockexcept exception1: Exception1-blockexcept exception2: Exception2-blockelse: Else-blockfinally: Finally-block

Hier als er een exception is in de Try-block, wordt deze afgehandeld in het except of else blok. Maar het maakt niet uit in welke volgorde de uitvoering loopt, we kunnen er zeker van zijn dat de Finally-block wordt uitgevoerd, zelfs als er een fout optreedt. Dit is handig bij het opschonen van de resources.

Lees meer over exception handling in Python programmeren.

for

for wordt gebruikt voor looping. Over het algemeen gebruiken we for wanneer we het aantal keren weten dat we een lus willen maken.

In Python kunnen we het gebruiken met elk type sequentie zoals een lijst of een string. Hier is een voorbeeld waarin for wordt gebruikt om door een lijst met namen te gaan:

names = for i in names: print('Hello '+i)

Output

Hello JohnHello MonicaHello StevenHello Robin

Lees meer over Python for loop.

from, import

import keyword wordt gebruikt om modules te importeren in de huidige namespace. from…import wordt gebruikt om specifieke attributen of functies in de huidige namespace te importeren. Bijvoorbeeld:

import math

zal de math module importeren. Nu kunnen we de cos() functie daarin gebruiken als math.cos(). Maar als we alleen de cos() functie willen importeren, kunnen we dit doen met from as

from math import cos

nu kunnen we de functie gewoon gebruiken als cos(), zonder math.cos() te hoeven schrijven.

Lees meer over Python modules en import verklaring.

global

global wordt gebruikt om aan te geven dat een variabele binnen de functie globaal is (buiten de functie).

Als we de waarde van een globale variabele moeten lezen, is het niet nodig om deze te definiëren als global. Dit wordt begrepen.

Als we de waarde van een globale variabele binnen een functie moeten wijzigen, dan moeten we deze declareren met global. Anders wordt een lokale variabele met die naam aangemaakt.

Het volgende voorbeeld zal ons helpen dit te verduidelijken.

globvar = 10def read1(): print(globvar)def write1(): global globvar globvar = 5def write2(): globvar = 15read1()write1()read1()write2()read1()

Output

1055

Hier leest de read1()-functie alleen de waarde van globvar. Dus, we hoeven het niet te declareren als global. Maar de functie write1() wijzigt de waarde, dus moet de variabele worden gedeclareerd als global.

In de uitvoer kunnen we zien dat de wijziging heeft plaatsgevonden (10 is veranderd in 5). De write2() probeert ook deze waarde te wijzigen. Maar we hebben het niet gedeclareerd als global.

Daarom wordt een nieuwe lokale variabele globvar aangemaakt die niet zichtbaar is buiten deze functie. Hoewel we deze lokale variabele wijzigen in 15, blijft de globale variabele ongewijzigd. Dit is duidelijk zichtbaar in onze uitvoer.

in

in wordt gebruikt om te testen of een sequentie (lijst, tuple, string enz.) een waarde bevat. Het retourneert True als de waarde aanwezig is, anders retourneert het False. Bijvoorbeeld:

>>> a = >>> 5 in aTrue>>> 10 in aFalse

Het tweede gebruik van in is het doorlopen van een reeks in een for lus.

for i in 'hello': print(i)

Output

hello

is

is wordt in Python gebruikt voor het testen van object identiteit. Terwijl de operator == wordt gebruikt om te testen of twee variabelen gelijk zijn of niet, wordt is gebruikt om te testen of de twee variabelen naar hetzelfde object verwijzen.

Hij retourneert True als de objecten identiek zijn en False als dat niet het geval is.

>>> True is TrueTrue>>> False is FalseTrue>>> None is NoneTrue

We weten dat er slechts één instantie van True, False en None in Python is, dus zijn ze identiek.

>>> == True>>> is False>>> {} == {}True>>> {} is {}False

Een lege lijst of een leeg woordenboek is gelijk aan een andere lege lijst of een leeg woordenboek. Maar het zijn geen identieke objecten, omdat ze zich afzonderlijk in het geheugen bevinden. Dit komt omdat lijst en woordenboek veranderlijk zijn (waarde kan worden gewijzigd).

>>> '' == ''True>>> '' is ''True>>> () == ()True>>> () is ()True

In tegenstelling tot lijst en woordenboek zijn string en tuple onveranderlijk (waarde kan niet worden gewijzigd als ze eenmaal zijn gedefinieerd). Vandaar dat twee gelijke string of tuple zijn ook identiek. Ze verwijzen naar dezelfde geheugenlocatie.

lambda

lambda wordt gebruikt om een anonieme functie (functie zonder naam) te maken. Het is een inline-functie die geen return-instructie bevat. Het bestaat uit een expressie die wordt geëvalueerd en teruggegeven. Bijvoorbeeld:

a = lambda x: x*2for i in range(1,6): print(a(i))

Output

246810

Hier hebben we een inline functie gemaakt die de waarde verdubbelt, met behulp van het lambda statement. We hebben dit gebruikt om de waarden in een lijst met 1 tot 5 te verdubbelen.

Lees meer over Python lamda functie.

nonlocal

Het gebruik van nonlocal sleutelwoord lijkt erg op het global sleutelwoord. nonlocal wordt gebruikt om aan te geven dat een variabele binnen een geneste functie (functie binnen een functie) niet lokaal is voor die functie, wat betekent dat deze in de buitenste functie ligt. Als we de waarde van een niet-lokale variabele binnen een geneste functie moeten wijzigen, dan moeten we dat aangeven met nonlocal. Anders wordt een lokale variabele met die naam aangemaakt in de geneste functie. Het volgende voorbeeld zal ons helpen dit te verduidelijken.

def outer_function(): a = 5 def inner_function(): nonlocal a a = 10 print("Inner function: ",a) inner_function() print("Outer function: ",a)outer_function()

Output

Inner function: 10Outer function: 10

Hier is de inner_function() genest binnen de outer_function.

De variabele a staat in de outer_function(). Dus, als we het willen wijzigen in de inner_function(), moeten we het declareren als nonlocal. Merk op dat a geen globale variabele is.

Hieruit blijkt dat de variabele met succes is gewijzigd in de geneste inner_function(). Het resultaat van het niet gebruiken van het nonlocal sleutelwoord is als volgt:

def outer_function(): a = 5 def inner_function(): a = 10 print("Inner function: ",a) inner_function() print("Outer function: ",a)outer_function()

Output

Inner function: 10Outer function: 5

Hier verklaren we niet dat de variabele a binnen de geneste functie nonlocal is. Daarom wordt een nieuwe lokale variabele met dezelfde naam aangemaakt, maar de niet-lokale a wordt niet gewijzigd, zoals te zien is in onze uitvoer.

pass

pass is een null statement in Python. Er gebeurt niets als het wordt uitgevoerd. Het wordt gebruikt als een placeholder.

Voorstel dat we een functie hebben die nog niet is geïmplementeerd, maar die we in de toekomst willen implementeren. Simpelweg schrijven,

def function(args):

in het midden van een programma geeft ons IndentationError. In plaats daarvan construeren we een lege body met het pass statement.

def function(args): pass

We kunnen hetzelfde doen in een lege class ook.

class example: pass

return

return statement wordt gebruikt binnen een functie om deze te verlaten en een waarde terug te geven.

Als we niet expliciet een waarde teruggeven, wordt None automatisch geretourneerd. Dit wordt geverifieerd met het volgende voorbeeld.

def func_return(): a = 10 return adef no_return(): a = 10print(func_return())print(no_return())

Output

10None

while

while wordt gebruikt voor looping in Python.

De statements binnen een while-lus blijven doorgaan totdat de conditie voor de while-lus evalueert naar False of een break statement wordt tegengekomen. Het volgende programma illustreert dit.

i = 5while(i): print(i) i = i – 1

Output

54321

Merk op dat 0 gelijk is aan False.

Lees meer over Python while-lus.

with

with verklaring wordt gebruikt om de uitvoering van een blok code te wikkelen binnen methoden die zijn gedefinieerd door de context manager.

Context manager is een klasse die __enter__ en __exit__ methoden implementeert. Gebruik van with verklaring zorgt ervoor dat de __exit__ methode wordt aangeroepen aan het eind van het geneste blok. Dit concept is vergelijkbaar met het gebruik van try…finally blok. Hier volgt een voorbeeld.

with open('example.txt', 'w') as my_file: my_file.write('Hello world!')

Dit voorbeeld schrijft de tekst Hello world! naar het bestand example.txt. Bestandsobjecten hebben __enter__ en __exit__ methode in zich gedefinieerd, dus ze fungeren als hun eigen context manager.

Eerst wordt de __enter__ methode aangeroepen, dan wordt de code binnen with statement uitgevoerd en tenslotte wordt de __exit__ methode aangeroepen. Methode __exit__ wordt ook aangeroepen als er een fout is opgetreden. In feite wordt de bestandsstroom gesloten.

yield

yield wordt binnen een functie gebruikt als een return-instructie. Maar yield retourneert een generator.

Generator is een iterator die één item per keer genereert. Een grote lijst met waarden neemt veel geheugen in beslag. Generatoren zijn nuttig in deze situatie omdat het slechts één waarde per keer genereert in plaats van alle waarden in het geheugen op te slaan. Bijvoorbeeld,

>>> g = (2**x for x in range(100))

zal een generator g creëren die machten van 2 genereert tot aan het getal twee tot de macht 99. We kunnen de getallen genereren met de functie next() zoals hieronder getoond.

>>> next(g)1>>> next(g)2>>> next(g)4>>> next(g)8>>> next(g)16

Enzovoort… Dit type generator wordt geretourneerd door het yield statement van een functie. Hier is een voorbeeld.

def generator(): for i in range(6): yield i*ig = generator()for i in g: print(i)

Output