30 coole Python-trucs voor beter code met voorbeelden

Python-vaardigheden zijn de afgelopen jaren steeds meer in trek. Om je te helpen je Python-programmeervaardigheden te ontwikkelen, hebben we 30 coole Python-trucs verzameld die je kunt gebruiken om je code te verbeteren. Probeer er de komende 30 dagen elke dag één te leren en bekijk ook onze post over best practices voor Python om ervoor te zorgen dat je code topklasse is. 

Als je Python-vaardigheden wat roestig zijn, kun je ze ook bijspijkeren met ons Python Programming skill track.

Trucs voor sequenties & datastructuren

#1 Slicen

a = "Hello World!"
print(a[::-1])

"""
!dlroW olleH
"""

Slicen is een feature in Python die op indexering berust en gebruikers toestaat een subverzameling van een sequentie te benaderen. Een index is simpelweg de positie van een element in een sequentie. Als het sequentietype muteerbaar is, kun je slicing gebruiken om data te extraheren en te wijzigen. 

Let op: We kunnen ook slicen op een immuteerbare sequentie, maar proberen de slice te wijzigen zal een TypeError opleveren. 

Het formaat waarin slices worden toegepast is: sequence[start:stop:step]. Als er geen waarden zijn opgegeven voor de parameters start, stop en step, dan worden de standaardwaarden gebruikt. De defaults zijn: 

• "start" is standaard 0 
• "stop" is standaard de lengte van de sequentie
• "step" is standaard 1 als deze niet is opgegeven. 

Bij sequence[start:stop] worden de elementen geretourneerd vanaf de startindex tot en met stop - 1 (de stopindex is exclusief). 

We kunnen ook negatieve indexen doorgeven, die je kunt gebruiken om de sequentie om te keren. In een lijst met 4 elementen is de 0e index bijvoorbeeld ook de -4 index, en de laatste index is ook -1. In de voorbeeldcode hierboven is deze kennis toegepast op de parameter step van de sequentie. Daardoor werd de string achterstevoren geprint, beginnend bij het einde van de sequentie tot index 0.   

#2 In-place wisselen / gelijktijdige toekenning

a = 10
b = 5
print(f"First: {a, b}")

"""
First: (10, 5)
"""

a, b = b, a + 2
print(f"Second: {a, b}")

"""
Second: (5, 12)
"""

Als je eerste indruk was dat de waarde van b 7 zou zijn in plaats van 12, ben je in de val van in-place wisselen getrapt. 

In Python kunnen we iterables in één toekenning uitpakken naar variabelen met automatisch unpacken. Bijvoorbeeld: 

a, b, c = [1, 2, 3]
print(a)
print(b)
print(c)

"""
1
2
3
"""

We kunnen ook meerdere waarden verzamelen in één variabele met * – deze Python-truc heet packen. Hieronder een voorbeeld van packen.  

a, *b = 1, 2, 3
print(a, b)
"""
1 [2, 3]
"""

Het combineren van automatisch packen en unpacken levert een techniek op die bekendstaat als gelijktijdige toekenning. We kunnen gelijktijdige toekenning gebruiken om een reeks waarden aan een reeks variabelen toe te wijzen.

#3 Lijsten vs. tuples 

import sys

a = [1, 2, 3, 4, 5]
b = (1, 2, 3, 4, 5)

print(f"List size: {sys.getsizeof(a)} bytes")
print(f"Tuple size: {sys.getsizeof(b)} bytes")

"""
List size: 52 bytes
Tuple size: 40 bytes
"""

De meeste Python-programmeurs zijn vertrouwd met de datastructuur lijst. Hetzelfde geldt niet per se voor tuples. Ze zijn allebei iterables, staan indexering toe en kunnen heterogene datatypes opslaan. Maar er zijn situaties waarin je beter een tuple dan een lijst kunt gebruiken. 

Allereerst zijn lijsten muteerbaar, wat betekent dat we ze naar wens kunnen aanpassen: 

a = [1,2,3,4,5]
a[2] = 8
print(a)

"""
[1,2,8,4,5]
"""

Tuples daarentegen zijn immuteerbaar, wat betekent dat proberen ze te wijzigen een TypeError zal opleveren. 

Om die reden zijn tuples geheugen-efficiënter, omdat Python precies het juiste geheugenblok kan reserveren voor de data. Bij een lijst moet extra geheugen gereserveerd worden voor het geval we deze uitbreiden – dit heet dynamische geheugenallocatie. 

TL;DR: In situaties waarin je niet wilt dat de data verandert, verdient een tuple de voorkeur boven een lijst om geheugenredenen. Tuples zijn ook sneller dan lijsten. 

Leer meer over Python-datastructuren in deze tutorial. 

#4 Generators

a = [x * 2 for x in range(10)]
b = (x * 2 for x in range(10))

print(a)
print(b)

"""
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
<generator object <genexpr> at 0x7f61f8808b50>
"""

List comprehensions zijn de Pythonic manier om een lijst te maken op basis van een andere iterable – dit is veel sneller dan een for-lus gebruiken. Maar wat gebeurt er als je per ongeluk de haakjes verandert van [] naar ()? Dan krijg je een generatorobject.

In Python leveren ronde haakjes met list-comprehensionlogica een zogeheten generatorobject op. Generators zijn een speciaal soort iterable. In tegenstelling tot lijsten slaan ze hun items niet op. In plaats daarvan bewaren ze instructies om elk element op volgorde te genereren en de huidige staat van de iteratie.

Elk element wordt pas gegenereerd op verzoek met een techniek die luie evaluatie heet. Het belangrijkste voordeel van deze Python-tip met een generator is dat het minder geheugen gebruikt, omdat de volledige sequentie niet in één keer wordt opgebouwd. 

#5 Aliasing 

a = [1, 2, 3, 4 ,5]
b = a

# Change the 4th index in b
b[4] = 7

print(id(a))
print(id(b))
print(a) # Remember we did not explicitly make changes to a.

"""
15136008
15136008
[1, 2, 3, 4, 7]
"""

Python is een objectgeoriënteerde programmeertaal – alles is een object. Dus het toekennen van een object aan een identifier creëert een referentie naar dat object. 

Wanneer we de ene identifier aan een andere toekennen, eindigen we met twee identifiers die naar hetzelfde object verwijzen. Dit heet aliasing. Wijzigingen in de ene alias beïnvloeden de andere. Soms is dit gewenst, maar vaak overvalt het je. 

Eén manier om dit te omzeilen is aliasing vermijden bij gebruik van muteerbare objecten. Een andere oplossing is een kloon van het oorspronkelijke object te maken in plaats van een referentie. 

De meest eenvoudige manier om een kloon te maken is slicing gebruiken: 

b = a[:] 

Dit maakt een nieuwe referentie naar een lijstobject in de identifier b. 

Je kunt nog veel andere oplossingen bedenken, zoals list(a) aanroepen bij toekenning aan een andere identifier of de methode copy() gebruiken. 

#6 De ‘not’-operator

a = []
print(not a)

"""
True
"""

Onze volgende Python-tip is de makkelijkste manier om te controleren of je datastructuur leeg is: met de not-operator. Python’s ingebouwde not is een logische operator die True retourneert als de expressie niet waar is, anders retourneert hij False – hij draait de waarheidswaarde van booleaanse expressies en objecten om.  

Een andere manier waarop je dit ziet, is in een if-statement: 

if not a:
    # do something... 

Wanneer a True is, zal de not-operator False retourneren, en omgekeerd. 

Het is even schakelen in je hoofd, dus probeer het eens.

String- & outputtrucs

#7 F-strings

first_name = "John"
age = 19

print(f"Hi, I'm {first_name} and I'm {age} years old!")

"""
Hi, I'm John and I'm 19 years old!
"""

Soms moeten we een stringobject opmaken; Python 3.6 introduceerde een coole feature genaamd f-strings om dit te vereenvoudigen. Het helpt om te begrijpen hoe strings vóór die release werden geformatteerd om de nieuwe methode beter te waarderen. 

Zo werden strings vroeger geformatteerd: 

first_name = "John"
age  = 19

print("Hi, I'm {} and I'm {} years old!".format(first_name, age))

"""
Hi, I'm John and I'm 19 years old!
"""

Kortom, de nieuwe manier van formatteren is sneller, leesbaarder, compacter en lastiger om fout te doen.

Een andere toepassing van f-strings is een identifiernaam samen met de waarde printen. Dit werd geïntroduceerd in Python 3.8.

x = 10
y = 20
print(f"{x = }, {y = }")

"""
x = 10, y = 20
"""

Bekijk deze tutorial over F-string-formattering in Python om meer te leren. 

#8 De ‘end’-parameter van de print()-functie

languages = ["english", "french", "spanish", "german", "twi"]
print(' '.join(languages))

"""
english french spanish german twi
"""

Het is heel gebruikelijk om een print-statement te gebruiken zonder een van de optionele parameters te definiëren. Daardoor weten veel Pythonistas niet dat je de output tot op zekere hoogte kunt sturen.

Een optionele parameter die we kunnen aanpassen is end. De parameter end specificeert wat er aan het eind van een aanroep van print moet worden weergegeven. 

De default van end is "\n", wat Python vertelt een nieuwe regel te beginnen. In de code hierboven veranderden we dit naar een spatie. Daardoor werden alle elementen van onze lijst op dezelfde regel geprint.

#9 Toevoegen aan een tuple

a = (1, 2, [1, 2, 3])
a[2].append(4)
print(a)

"""
(1, 2, [1, 2, 3, 4])
"""

We weten al dat tuples immuteerbaar zijn – zie Python-truc #3 Lijsten vs. tuples. Pogingen om de staat van een tuple te wijzigen leveren een TypeError op. Maar als je een tupleobject ziet als een sequentie van namen met bindingen aan objecten die niet kunnen worden veranderd, kijk je er misschien anders naar.

De eerste twee elementen van onze tuple zijn integers – die zijn immuteerbaar. Het laatste element van onze tuple is een lijst, een muteerbaar object in Python.

Als we onze lijst beschouwen als gewoon een andere naam in een sequentie met een binding aan een object die niet kan worden veranderd, dan realiseren we ons dat de lijst nog steeds vanuit de tuple kan worden aangepast.

Zouden we dit in de praktijk aanraden? Waarschijnlijk niet, maar het is zo’n leuk-om-te-weten dingetje!

#10 Dictionaries samenvoegen

a = {"a": 1, "b": 2}
b = {"c": 3, "d": 4}

a_and_b = a | b
print(a_and_b)

"""
{"a": 1, "b": 2, "c": 3, "d": 4}
"""

In Python 3.9 en hoger is het mogelijk om dictionaries samen te voegen met | (bitwise OR). Er valt niet veel meer over deze Python-truc te zeggen, behalve dat het een veel leesbaardere oplossing is! 

Code style & syntaxttrucs

#11 Ternary-operator / conditionele expressies 

condition = True
name = "John" if condition else "Doe"

print(name)

"""
John
"""

In de code hierboven zie je wat bekendstaat als een ternary-operator – ook wel een conditionele expressie genoemd. We gebruiken ternary-operators om iets te evalueren op basis van of een conditie True of False is.

Een andere manier waarop we bovenstaande code hadden kunnen schrijven is als volgt:

condition = True
if condition:
    name = "John"
else:
    name = "Doe"

print(name)
"""
John
"""

Hoewel beide codeblokken tot dezelfde output leiden, zie je dat de ternary-versie ons veel kortere en helderdere code laat schrijven. Het is wat Pythonistas de meer ‘Pythonic’ manier zouden noemen. 

#12 Duplicaten uit lijsten verwijderen

a = [1, 1, 2, 3, 4, 5, 5, 5, 6, 7, 2, 2]
print(list(set(a)))

"""
[1, 2, 3, 4, 5, 6, 7]
"""

De eenvoudigste manier om dubbele elementen uit een lijst te verwijderen is de lijst omzetten naar een set (en desgewenst weer terug naar een lijst).

Qua muteerbaarheid lijken sets en lijsten in Python redelijk op elkaar. We kunnen in beide datastructuren elementen naar wens toevoegen en verwijderen, maar ze zijn toch heel verschillend.

Lijsten zijn geordend, nul-gebaseerd geïndexeerd en muteerbaar. Sets zijn ongeordend en niet geïndexeerd. De elementen in een set moeten van een immuteerbaar type zijn, ook al is de set zelf muteerbaar – proberen een element via een index op te halen of te wijzigen, levert een fout op.

Een ander belangrijk verschil tussen sets en lijsten is dat sets geen duplicaten kunnen bevatten. Dat hielp ons de dubbele elementen uit onze lijst te verwijderen.

#13 Losse underscore 

>>> print(_)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>

>>> 1 + 2
3

>>> print(_)
3

Underscore (_) is een geldige identifier in Python, dus je kunt hem gebruiken om naar een object te verwijzen. Maar underscore heeft nog een andere taak: de uitkomst van de laatste evaluatie opslaan.

De documentatie stelt dat "de interactieve interpreter het resultaat van de laatste evaluatie beschikbaar maakt in de variabele _. (Het wordt opgeslagen in de builtins-module, naast ingebouwde functies zoals print)."

Omdat we underscore niet aan een object hadden toegekend vóór de eerste aanroep, kregen we een fout. Toen we echter de uitkomst van 1 + 2 berekenden, sloeg de interactieve interpreter het resultaat voor ons op in de identifier _. 

#14 Underscore om waarden te negeren

for _ in range(100):
    print("The index doesn't matter")

"""
The index doesn't matter
The index doesn't matter
...
"""

In Python-tip #13 zagen we dat de interactieve interpreter het laatste resultaat van een evaluatie beschikbaar maakt in de identifier underscore (_), maar dat is niet de enige usecase.

We kunnen hem ook gebruiken om objecten te representeren waar we niet om geven of die we later in het programma niet gaan gebruiken. Dit is belangrijk, omdat het gebruiken van een identifier in plaats van underscore (_) een F841-fout oplevert wanneer we onze code linten. Een F841-fout geeft simpelweg aan dat een lokale variabelenaam is toegewezen maar niet gebruikt in het programma, wat slechte praktijk is.

#15 Afsluitende underscores

list_ = [0, 1, 2, 3, 4]
global_ = "Hi there" 

In het verlengde van de vorige twee trucs over het gebruik van underscore (_): een andere toepassing is conflicten met Python-sleutelwoorden vermijden. 

PEP 8 vermeldt dat een afsluitende underscore (_) "conform afspraak wordt gebruikt om conflicten met Python-sleutelwoorden te vermijden." Er staat ook dat "het over het algemeen beter is om één afsluitende underscore toe te voegen dan een afkorting of spelfout te gebruiken. Dus list_ is beter dan lst."

#16 Voorafgaande underscores

class Example:
    def __init__(self):
        self._internal = 2
        self.external = 20

Je ziet vaak dat ervaren Python-programmeurs een underscore voor een identifier- of methodenaam plaatsen – en met goede reden.

De underscore voorafgaand aan een identifier of methode heeft een verborgen betekenis: deze variabele of methode is alleen bedoeld voor intern gebruik. Het is in essentie een disclaimer aan andere programmeurs die in PEP 8 is vastgelegd, maar niet door Python wordt afgedwongen. Voorafgaande underscores zijn dus een zwakke aanduiding.

In tegenstelling tot Java kent Python geen sterk onderscheid tussen private en public variabelen. Met andere woorden: het heeft alleen betekenis omdat de Python-community ermee heeft ingestemd. Hun aanwezigheid beïnvloedt het gedrag van je programma’s niet.

#17 Underscore als visueel hulpmiddel

Hier is de laatste tip over underscores; tot nu toe hebben we drie verschillende usecases behandeld, maar je kunt onze tutorial lezen om meer te leren over de rol van underscore (_) in Python. 

number = 1_500_000
print(number)

"""
15000000
"""

Een andere manier waarop we underscore kunnen gebruiken is als visuele scheiding voor cijfergroepering in gehele getallen, kommagetallen en complexe getallen – dit is geïntroduceerd in Python 3.6. 

Het idee was om de leesbaarheid te verbeteren van lange literals of literals waarvan de waarde duidelijk in delen gescheiden moet zijn – je kunt er meer over lezen in PEP 515.

Code style & syntaxttrucs

#18 __name__ == “__main__” 

if __name__ == "__main__":
    print("Read on to understand what is going on when you do this.")

"""
print("Read on to understand what is going on when you do this.")
"""

De kans is groot dat je deze syntax in diverse Python-programma’s hebt gezien; Python gebruikt een speciale naam "__main__" en stelt die in op een identifier genaamd __name__ als het Python-bestand dat wordt uitgevoerd het hoofdprogramma is.

Als we besluiten de module in de screenshot in een andere module (Python-bestand) te importeren en dat bestand uit te voeren, is de expressie in onze code onwaar. Dit komt doordat bij importeren uit een andere module de identifier __name__ wordt ingesteld op de naam van de module (het Python-bestand). 

#19 De ‘setdefault’-methode 

import pprint

text = "It's the first of April. It's still cold in the UK. But I'm going to the museum so it should be a wonderful day"

counts = {}
for word in text.split():
    counts.setdefault(word, 0)
    counts[word] += 1

pprint.pprint(counts)

"""
{'April.': 1,
'But': 1,
"I'm": 1,
"It's": 2,
'UK.': 1,
'a': 1,
'be': 1,
'cold': 1,
'day': 1,
'first': 1,
'going': 1,
'in': 1,
'it': 1,
'museum': 1,
'of': 1,
'should': 1,
'so': 1,
'still': 1,
'the': 3,
'to': 1,
'wonderful': 1}
"""

Je wilt misschien een waarde instellen voor verschillende sleutels in een dictionary. Bijvoorbeeld wanneer je het aantal woorden in een corpus bijhoudt. De gebruikelijke manier is als volgt: 

1. Controleren of de sleutel in de dictionary bestaat
2. Zo ja, verhoog de waarde met 1.
3. Zo nee, voeg hem toe en zet de waarde op 1.

Zo ziet dat eruit in code:

counts = {}
for word in text.split():
    if word in counts:
        counts[word] += 1
    else:
      counts[word] = 1

Een beknoptere manier is de methode setdefault() op je dictionary-object te gebruiken.

Het eerste argument dat aan de methode wordt doorgegeven is de sleutel waar we op willen controleren. Het tweede argument is de waarde die aan de sleutel wordt toegekend als die nog niet bestaat in de dictionary – als de sleutel al bestaat, retourneert de methode de sleutelwaarde. Die wordt dan dus niet gewijzigd.

Trucs voor programmastructuur

#20 Regex matchen

import re

number = re.compile(r"(0)?(\+44)?\d{10}")
num_1 = number.search("My number is +447999999999")
num_2 = number.search("My number is 07999999999")

print(num_1.group())
print(num_2.group())

"""
'+447999999999'
'07999999999'
"""

Reguliere expressies laten je een tekstpatroon specificeren om naar te zoeken; de meeste mensen weten dat je met CTRL + F (Windows) kunt zoeken, maar als je niet precies weet waar je naar zoekt, hoe vind je het dan? Het antwoord is: zoek naar patronen.  

Bijvoorbeeld, Britse nummers volgen een vergelijkbaar patroon: ze beginnen met een nul plus tien cijfers, of met +44 in plaats van nul en tien cijfers – het tweede geval is het internationale formaat. 

Reguliere expressies besparen enorm veel tijd. Als we in plaats van regex regels zouden coderen om de gevallen in onze afbeelding te vangen, kan dat zo 10+ regels code kosten. 

Leren hoe reguliere expressies werken is belangrijk, zelfs als je geen code schrijft. De meeste moderne teksteditors en tekstverwerkers laten je reguliere expressies gebruiken voor zoeken-en-vervangen.

#21 Regex pipe

import re

heros = re.compile(r"Super(man|woman|human)")

h1 = heros.search("This will find Superman")
h2 =  heros.search("This will find Superwoman")
h3 = heros.search("This will find Superhuman")

print(h1.group())
print(h2.group())
print(h3.group())

"""
Superman
Superwoman
Superhuman
"""

Reguliere expressies hebben een speciaal teken genaamd pipe (|) waarmee je één van meerdere expressies kunt matchen, en ze kunnen overal worden gebruikt. Superhandig als je meerdere vergelijkbare patronen hebt.

’Superman’, ’Superwoman’ en ’Superhuman’ hebben bijvoorbeeld allemaal hetzelfde voorvoegsel. Je kunt de pipe gebruiken om het terugkerende deel van het patroon te behouden en de delen te variëren die moeten verschillen. Opnieuw: kostbare tijdwinst.

Let op de valkuil: als alle expressies die je wilt matchen in dezelfde tekst voorkomen, wordt het eerste voorkomende matchende stuk tekst geretourneerd – d.w.z. "An example text containing Superwoman, Superman, Superhuman" zou Superwoman retourneren.

#22 De ‘sep’-parameter van de print()-functie

day = "04"
month = "10"
year = "2022"

print(day, month, year)
print(day, month, year, sep = "")
print(day, month, year, sep = ".")

"""
04 10 2022
04/10/2022
04.10.2022
"""

Het aantal Python-programmeurs dat niet op de hoogte is van de volledige mogelijkheden van print() is schrikbarend; als “Hello World” je eerste programma was, was de functie print() waarschijnlijk een van de eerste ingebouwde functies die je behandelde. We gebruiken print() om geformatteerde berichten op het scherm te tonen, maar er is nog veel meer mogelijk met print(). 

In de code hierboven laten we verschillende manieren zien om onze geformatteerde boodschap te tonen. De parameter sep is een optioneel argument in de functie print() waarmee we kunnen aangeven hoe objecten gescheiden moeten worden als we er meer dan één meegeven. 

Standaard worden ze gescheiden door een spatie, maar we hebben dit aangepast in onze print-statements – één waar sep is ingesteld op "" en een andere waar sep is ingesteld op ".".

#23 Lambda-functies 

def square(num:int) -> int:
    return num ** 2

print(f"Function call: {square(4)}")
"""
Function call: 16
"""

square_lambda = lambda x: x**2
print(f"Lambda function: {square_lambda(4)}")
"""
Lambda functional: 16
"""

Lambda-functies brengen je naar het meer gevorderde werk dat je met Python kunt doen – leer Intermediate Python met deze cursus. Ze lijken op het eerste gezicht ingewikkeld, maar zijn vrij simpel.

In ons voorbeeld gebruikten we één argument, maar we hadden er ook meerdere kunnen gebruiken:

square = lambda a, b: a ** b
print(f"Lambda function: {square(4, 2)}")
"""
16
"""

Kort gezegd stelt het sleutelwoord lambda ons in staat kleine, beperkte, anonieme functies in één regel te maken. Ze gedragen zich als een gewone functie gedeclareerd met het def-sleutelwoord, behalve dat deze functies geen naam hebben.

#24 De ‘swapcase’-methode

string = "SoMe RaNDoM sTriNg"
print(string.swapcase())

"""
sOmE rAndOm StRInG
"""

De methode swapcase() wordt toegepast op een stringobject en laat ons hoofdletters in kleine letters veranderen en omgekeerd in één regel code. Er zijn niet veel usecases voor swapcase(), maar het is goed om te kennen.

#25 De ‘isalnum’-methode

password = "ABCabc123"
print(password.isalnum())

"""
True
"""

Stel, we maken een programma waarin gebruikers een wachtwoord moeten invoeren, maar het moet een combinatie van letters en cijfers bevatten. Dat kunnen we in één regel code doen door isalnum() op de stringinstantie aan te roepen.

De methode controleert of alle tekens alfabetisch (A-Za-z) en numeriek (0-9) zijn. Een spatie of symbool (!#%$&? etc.) retourneert False.

#26 Foutafhandeling

def get_ration(x:int, y:int) -> int:
    try:
        ratio = x/y
    except ZeroDivisionError:
        y = y + 1
        ratio = x/y
    return ratio

print(get_ration(x=400, y=0))

"""
400.0
"""

Python-programma’s stoppen wanneer ze een fout tegenkomen.

Soms willen we dat gedrag niet, bijvoorbeeld wanneer een eindgebruiker met onze code interageert. Hoe vervelend zou het zijn als onze code in zo’n geval voortijdig stopt?

Er zijn verschillende denkrichtingen over hoe om te gaan met uitzonderingen. De meeste Python-programmeurs omarmen doorgaans het idee dat het makkelijker is om vergeving te vragen dan toestemming te krijgen. Dat betekent dat ze liever een opgeworpen fout opvangen door omringende context te bieden die de uitzondering kan afhandelen. Het idee hierachter is dat het geen zin heeft om tijd te verspillen met het afvangen van alle mogelijke uitzonderingsgevallen.

Maar dit geldt alleen als er een mechanisme is om met een probleem om te gaan nadat het zich voordoet.

#27 Verschillen in lijsten identificeren

list_1 = [1, 3, 5, 7, 8]
list_2 = [1, 2, 3, 4, 5, 6, 7, 8, 9]

solution_1 = list(set(list_2) - set(list_1))
solution_2 = list(set(list_1) ^ set(list_2))
solution_3 = list(set(list_1).symmetric_difference(set(list_2)))

print(f"Solution 1: {solution_1}")
print(f"Solution 2: {solution_2}")
print(f"Solution 3: {solution_3}")

"""
Solution 1: [9, 2, 4, 6]
Solution 2: [2, 4, 6, 9]
Solution 3: [2, 4, 6, 9]
"""

Hier zijn drie verschillende methoden om het verschil tussen twee lijsten in Python te vergelijken. 

Let op: Tenzij je zeker weet dat list_1 een subset is van list_2, is oplossing 1 niet hetzelfde als de andere twee oplossingen.

#28 Args & kwargs

def some_function(*args, **kwargs):
    print(f"Args: {args}")
    print(f"Kwargs: {kwargs}")

some_function(1, 2, 3,  a=4, b=5, c=6)

"""
Args: (1, 2, 3)
Kwargs: {'a': 4, 'b': 5, 'c': 6}
"""

We gebruiken *args en **kwargs als parameters van een functie wanneer we niet weten hoeveel variabelen onze functie kan verwachten. 

De parameter *args laat ons een variabel aantal parameters aan een functie doorgeven wanneer ze niet van een sleutelwoord zijn voorzien (d.w.z. de parameters die we doorgeven hebben geen bijbehorende naam nodig). De parameter **kwargs stelt ons in staat een willekeurig aantal keyword-parameters door te geven aan een functie.

Eerlijk gezegd zijn de woorden *args en **kwargs niet zo magisch: de echte magie zit in de sterretjes (*). Dit betekent dat we elk woord na de sterretjes hadden kunnen gebruiken, maar het gebruik van args en kwargs is gangbare praktijk en breed gedragen onder Python-ontwikkelaars. 

#29 De ellipsis

print(...)

"""
Ellipsis
"""

def some_function():
    ...

# Alternative solution
def another_function():
    pass

De Ellipsis is een Python-object dat je kunt aanroepen door drie puntjes (...) te gebruiken of het object zelf (Ellipsis) te gebruiken.

De meest opmerkelijke toepassing is voor toegang en slicing van multidimensionale arrays in NumPy, bijvoorbeeld:

import numpy as np

arr = np.array([[2,3], [1,2], [9,8]])

print(arr[...,0])
"""
[2 1 9]
"""
print(arr[...])

"""
[[2 3]
[1 2]
[9 8]]
"""

Maar een andere toepassing van Ellipsis is als placeholder in een niet-geïmplementeerde functie. 

Dit betekent dat je Ellipsis, ..., of pass kunt gebruiken, en dat ze allemaal geldig zijn.

#30 List comprehension

even_numbers = [x for x in range(10) if x % 2 == 0 and x != 0]
print(even_numbers)

"""
[2, 4, 6, 8]
"""

Onze laatste Python-truc is list comprehensions, een elegante manier om een lijst te maken uit een andere sequentie. Ze laten je geavanceerde logica en filtering uitvoeren, zoals we hierboven hebben gedaan.

Er zijn andere manieren om hetzelfde doel te bereiken; we hadden bijvoorbeeld een lambda-functie kunnen gebruiken zoals hieronder:

even_numbers = list(filter(lambda x: x % 2 ==0 and x != 0, range(10)))
print(even_numbers)
"""
[0, 2, 4, 6, 8]
"""

Maar veel Pythonistas zouden stellen dat deze oplossing een stuk minder leesbaar is dan de list comprehension.