30 coole Python-trucs voor betere 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 met Python best practices om ervoor te zorgen dat je code topklasse is. 

Als je Python-vaardigheden wat zijn weggezakt, kun je ze ook aanscherpen met onze Python Skill Track.

Trucs voor sequenties & datastructuren

#1 Slicing

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

"""
!dlroW olleH
"""

Slicing is een feature in Python die op indexering berust en gebruikers in staat stelt een subset 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 slicing ook gebruiken op een immuteerbare sequentie, maar een poging om 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 in de parameters start, stop en step, dan worden de standaardwaarden gebruikt. De standaardwaarden zijn: 

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

Als je sequence[start:stop] gebruikt, worden de elementen geretourneerd vanaf de startindex tot en met stop - 1 (de stopindex is niet inbegrepen). 

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 bovenstaande code is deze kennis toegepast op de parameter step van de sequentie. Daardoor werd de string achterstevoren geprint, van het einde van de sequentie naar index 0.   

#2 In-place swap / 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 swappen getrapt. 

In Python kunnen we iterables in één toekenning uitpakken naar variabelen met automatische unpacking. 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 packing. Hieronder een voorbeeld van packing.  

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

Door automatisch packen en unpacken te combineren, ontstaat een techniek die bekendstaat als gelijktijdige toekenning. Daarmee kun je een reeks waarden aan een reeks variabelen toekennen.

#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 bekend met de datastructuur list. Dat geldt niet altijd voor tuples. Het zijn allebei iterables, ze staan indexering toe en kunnen heterogene datatypen opslaan. Maar er zijn situaties waarin je beter een tuple dan een list kunt gebruiken. 

Allereerst: lijsten zijn muteerbaar, wat betekent dat we ze naar believen 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 een poging om ze te wijzigen een TypeError zal opleveren. 

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

TL;DR: In scenario’s 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 uit een andere iterable – veel sneller dan een for-lus. Maar wat gebeurt er als je per ongeluk de haken verandert van [] naar ()? Dan krijg je een generatorobject.

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

Elk element wordt alleen gegenereerd op aanvraag met een techniek die luie evaluatie heet. Het grootste voordeel van deze Python-tip met een generator is dat die 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. Een object aan een identifier toekennen betekent dus dat je een referentie naar het object maakt. 

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

Een manier om dit te vermijden is geen aliasing te gebruiken met muteerbare objecten. Een andere oplossing is een kloon van het originele object te maken in plaats van een referentie. 

De eenvoudigste manier om te klonen is slicing te gebruiken: 

b = a[:] 

Dit creëert een nieuwe referentie naar een list-object in de identifier b. 

Je kunt ook andere oplossingen gebruiken, 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 checken of je datastructuur leeg is: gebruik de not-operator. Pythons ingebouwde not is een logische operator die True retourneert als de expressie niet waar is, anders retourneert die False – hij keert 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, dus probeer het vooral uit.

Trucs voor strings & output

#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, f-strings, om dit te vereenvoudigen. Het helpt om te begrijpen hoe strings eerder 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!
"""

De nieuwe manier van formatteren is in wezen sneller, leesbaarder, beknopter en lastiger om fouten mee te maken.

Een ander gebruik van f-strings is om een identifiernaam samen met de waarde te 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 formatting 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 vrij gebruikelijk om een print-statement te gebruiken zonder optionele parameters te definiëren. Daardoor weten veel Pythonistas niet dat je de output tot op zekere hoogte kunt sturen.

Eén optionele parameter die we kunnen aanpassen is end. De parameter end specificeert wat er aan het einde van een aanroep van een print-statement moet worden weergegeven. 

De standaardwaarde van end is "\n", wat Python vertelt om een nieuwe regel te beginnen. In de code hierboven hebben we dit veranderd naar een spatie. Daardoor worden 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. Een poging om de staat van een tuple te wijzigen levert een TypeError op. Maar als je een tuple ziet als een sequentie van namen met bindingen aan objecten die niet veranderd kunnen worden, kijk je er misschien anders tegenaan.

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

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

Zouden we je aanraden dit in de praktijk te doen? Waarschijnlijk niet, maar het is wel handig om te weten!

#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 dictionaries samen te voegen met | (bitwise OR). Er valt niet veel meer over deze Python-truc te zeggen, behalve dat het een veel beter leesbare oplossing is! 

Trucs voor stijl & syntaxis

#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 de code hierboven hadden kunnen schrijven, is als volgt:

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

print(name)
"""
John
"""

Hoewel beide codeblokken hetzelfde resultaat opleveren, zie je dat de ternary-conditional ons toestaat veel kortere en duidelijkere code te schrijven. Dit is wat Pythonistas ‘Pythonic’ 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 simpelste manier om dubbele elementen uit een lijst te verwijderen, is de lijst om te zetten naar een set (en desgewenst weer terug naar een lijst).

Qua muteerbaarheid zijn sets en lijsten best vergelijkbaar in Python. We kunnen aan beide datastructuren naar wens elementen 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 is dat sets geen duplicaten kunnen bevatten. Dat hielp ons om de dubbele elementen uit onze lijst te verwijderen.

#13 Losstaande 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 het is mogelijk om die te gebruiken om naar een object te verwijzen. Maar underscore heeft ook een andere taak: het resultaat 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 vóór de eerste aanroep geen object hadden toegekend, kregen we een fout. Toen we echter de uitkomst van 1 + 2 berekenden, sloeg de 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 zullen gebruiken. Dit is belangrijk, omdat het gebruik van een gewone identifier in plaats van een underscore (_) een F841-fout oplevert wanneer we onze code linten. Een F841-fout geeft simpelweg aan dat een lokale variabelenaam is toegekend maar niet gebruikt, wat een slechte praktijk is.

#15 Afsluitende underscores

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

Aansluitend op de voorgaande twee trucs over het gebruik van underscore (_) in Python: een ander doel is het vermijden van conflicten met Python-zoekwoorden. 

PEP 8 vermeldt dat een afsluitende underscore (_) "volgens conventie wordt gebruikt om conflicten met Python-zoekwoorden te vermijden." Het stelt ook dat "het over het algemeen beter is een enkele afsluitende underscore toe te voegen dan een afkorting of verbastering 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 zetten – en met reden.

De underscore vóór een identifier of methode heeft een impliciete betekenis: deze variabele of methode is alleen bedoeld voor intern gebruik. In wezen is het een disclaimer aan andere programmeurs die in PEP 8 is vastgelegd, maar niet door Python wordt afgedwongen. Voorafgaande underscores zijn dus een zwakke indicator.

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

#17 Underscore als visuele scheiding

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

number = 1_500_000
print(number)

"""
15000000
"""

Een andere manier waarop we de underscore kunnen gebruiken, is als visuele scheiding voor cijfergroepering in gehele, floating-point- en complexe getalliteralen – dit werd geïntroduceerd in Python 3.6. 

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

Trucs voor stijl & syntaxis

#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 syntaxis in meerdere Python-programma’s hebt gezien; Python gebruikt een speciale naam "__main__" en zet die op een identifier genaamd __name__ als het Python-bestand dat wordt uitgevoerd het hoofdprogramma is.

Als we besluiten de module die in de screenshot wordt getoond 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 vanuit een andere module de identifier __name__ wordt gezet op de naam van de module (het Python-bestand). 

#19 De methode ‘setdefault’ 

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 zetten voor verschillende sleutels in een dictionary. Bijvoorbeeld wanneer je de telling van woorden in een corpus bijhoudt. De gebruikelijke manier is als volgt: 

1. Check of de sleutel bestaat in de dictionary
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 dictionaryobject 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 we aan de sleutel geven als die nog niet in de dictionary bestaat – als de sleutel wel 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 stellen je in staat een tekstpatroon te specificeren om naar te zoeken; de meeste mensen weten dat je kunt zoeken met CTRL + F (Windows), 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 hebben een nul aan het begin plus tien cijfers, of +44 in plaats van nul en tien cijfers – het tweede geval geeft aan dat het het internationale formaat is. 

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 essentieel, zelfs als je geen code schrijft. De meeste moderne teksteditors en tekstverwerkers staan het gebruik van regex toe bij 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, de pipe (|), waarmee je één van meerdere expressies kunt matchen, en die je overal kunt gebruiken. Dit is superhandig wanneer je meerdere vergelijkbare patronen hebt.

‘Superman’, ‘Superwoman’ en ‘Superhuman’ hebben bijvoorbeeld allemaal hetzelfde prefix. Je kunt de pipe gebruiken om het terugkerende deel van het patroon te behouden en de delen te variëren die anders moeten zijn. Opnieuw: tijdbesparend.

Let op: 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 bekend is met de volledige mogelijkheden van de print()-functie is schrikbarend; als “Hello World” je eerste programma was, was print() waarschijnlijk een van de eerste ingebouwde functies die je behandelde bij het leren van Python. We gebruiken print() om geformatteerde berichten op het scherm te tonen, maar er is veel meer mogelijk met print(). 

In de code hierboven laten we verschillende manieren zien om ons geformatteerde bericht weer te geven. 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 gedrag aangepast met 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 deel van wat je met Python kunt doen – leer Intermediate Python met deze cursus. Ze lijken op het eerste gezicht ingewikkeld, maar ze zijn vrij simpel.

In onze voorbeeldcode gebruikten we maar éé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 laat het sleutelwoord lambda ons kleine, beperkte, anonieme functies in één regel maken. Ze gedragen zich als een normale functie die met def is gedeclareerd, behalve dat deze functies geen naam hebben.

#24 De methode ‘swapcase’

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

"""
sOmE rAndOm StRInG
"""

De methode swapcase() wordt toegepast op een stringobject en stelt ons in staat hoofdletters om te zetten naar kleine letters en omgekeerd in één regel code. Er zijn niet heel veel usecases voor swapcase(), maar het is leuk om te kennen.

#25 De methode ‘isalnum’

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

"""
True
"""

Stel dat we een programma maken dat gebruikers een wachtwoord laat invoeren, maar het moet een combinatie van cijfers en letters zijn. Dat kan in één regel code door isalnum() aan te roepen op de stringinstantie.

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 interacteert. Hoe vervelend zou het zijn als onze code voortijdig stopt in zo’n geval?

Er zijn verschillende denkrichtingen over hoe om te gaan met uitzonderlijke gevallen. 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 in staat is een uitzondering af te handelen. Het idee hierachter is dat het geen zin heeft tijd te verspillen aan het proberen te beschermen tegen alle mogelijke uitzonderingen.

Maar dit gaat alleen op 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 moet verwachten. 

De parameter *args stelt ons in staat een variabel aantal parameters aan een functie door te geven wanneer ze niet met een sleutelwoord zijn (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 aan een functie door te geven.

Eerlijk gezegd zijn de woorden *args en **kwargs niet zo magisch: de echte magie zit in de sterretjes (*). Dat betekent dat we elk woord na de sterretjes hadden kunnen gebruiken, maar het gebruik van args en kwargs is gangbare praktijk en wordt breed aangehouden 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 een sequentie van drie puntjes (...) te gebruiken of door het object zelf (Ellipsis) aan te roepen.

De meest opvallende toepassing is het benaderen en slicen 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. Je kunt er geavanceerde logica en filtering mee toepassen, 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 zullen stellen dat deze oplossing veel minder leesbaar is dan de list comprehension.