Bij het programmeren zijn er momenten waarop je denkt: "Hé!" Het zijn de momenten waarop complexe logica op een verbluffend eenvoudige en elegante manier wordt afgehandeld, de zogenaamde 'Pythonic' code.

Vandaag introduceer ik drie eenvoudige maar krachtige Pythonic code snippets die ons samen hebben ontroerd.

1. Prefix slicing: de kracht van dynamiek

Commandbox 광고

Wanneer je het basispad uit een bestandspad wilt verwijderen en alleen het relatieve pad wilt verkrijgen, combineer je len() met string slicing.

# Voorbeeld 1
prefix = "/var/data/user/files"
p = "/var/data/user/files/report.txt"

if p.startswith(prefix):
    relative_path = p[len(prefix):]
    print(relative_path) 
    # /report.txt

Tot nu toe lijkt het niet anders dan p[22:] (het direct schrijven van het getal 22). Maar de werkelijke waarde van deze code komt naar voren wanneer de prefix dynamisch verandert.

✅ De Pythonic manier (de echte kracht)

Stel je voor dat je de dataspaden van meerdere gebruikers moet verwerken.

def get_relative_path(full_path, user_name):
    # ⭐️ De prefix verandert dynamisch op basis van user_name!
    prefix = f"/var/data/{user_name}/files"

    if full_path.startswith(prefix):
        # len() berekent elke keer de juiste dynamische lengte.
        # user1 heeft 22, long_user heeft 29...
        return full_path[len(prefix):]

    return full_path

# 'user1' (prefixlente 22)
path1 = "/var/data/user1/files/report.txt"
print(f"user1: {get_relative_path(path1, 'user1')}")

# 'long_user_name_2' (prefixlente 29)
path2 = "/var/data/long_user_name_2/files/document.pdf"
print(f"user2: {get_relative_path(path2, 'long_user_name_2')}")

Resultaat:

user1: /report.txt
user2: /document.pdf

😲 Ontroerend punt

De code is niet afhankelijk van de _inhoud_ of de _vaste lengte_ van de prefix. Het is alleen gebaseerd op de len() die de lengte in realtime berekent voor de [N:] slicing.

Dit is een onderhoudsvriendelijke en robuuste code die heel anders is dan hardcoding zoals p[22:].

2. Magische swap zonder tijdelijke variabele

Wanneer je de waarden van twee variabelen verwisselt, heb je geen tijdelijke variabele temp nodig.

✅ De Pythonic manier

a = 10
b = 20

# Verwisselen op de Python manier
a, b = b, a

print(f"a = {a}, b = {b}") 
# a = 20, b = 10

😲 Ontroerend punt

Dit is een kwestie van tuple packing en unpacking.

  1. b, a : De waarde aan de rechterkant van de gelijkteken, (20, 10), wordt in een tijdelijke tuple verpakt.

  2. a, b = ... : De waarden van deze tuple worden in volgorde toegewezen aan de a en b variabelen via 'unpacking'.

De intentie om 'a en b te verwisselen met b en a' is direct in de code vastgelegd.

3. Een for loop in één regel: de magie van comprehensies

Commandbox 광고

'Ik wil bepaalde gegevens gebruiken, alleen de elementen die aan specifieke voorwaarden voldoen selecteren, deze aanpassen en een nieuwe collectie maken.'

Deze lange zin wordt vaak vertaald naar 4-5 regels for loops. Python maakt dit proces echter in één regel.

Dictionaries: Sleutel en Waarde omdraaien

De verwondering van het verwisselen van variabelen zet zich voort in dictionaries. Het is een situatie waarbij je door een for loop heen k:v omzet naar v:k.

# Traditionele manier
my_dict = {'name': 'Alice', 'job': 'Engineer'}
inverted_dict = {}
for k, v in my_dict.items():
    inverted_dict[v] = k

✅ De Pythonic manier (Dictionary Comprehension)

my_dict = {'name': 'Alice', 'job': 'Engineer'}

# "Selecteer k, v uit my_dict, maak een nieuwe dict met v:k paren"
inverted_dict = {v: k for k, v in my_dict.items()}

print(inverted_dict)
# {'Alice': 'name', 'Engineer': 'job'}

(Let op: deze manier vereist dat de waarde uniek is.)

Lijsten: Nieuwe lijst maken met elementen die aan voorwaarden voldoen

Deze magie wordt vaker toegepast op lijsten. Laten we een lijst maken met de kwadraten van even getallen tussen 0 en 9.

# Traditionele manier
squares_of_evens = []
for i in range(10):
    if i % 2 == 0:
        squares_of_evens.append(i * i)

✅ De Pythonic manier (List Comprehension)

# "Voor i van 0 tot 9, als i even is, maak een lijst van i*i"
squares_of_evens = [i * i for i in range(10) if i % 2 == 0]

print(squares_of_evens)
# [0, 4, 16, 36, 64]

😲 Ontroerend punt

Comprehensie verandert de code niet in lange uitleg over 'hoe' je het maakt (hoe: lege lijst declareren, loops, append...), maar laat je in plaats daarvan declareren 'wat' je wilt.

Conclusie: wanneer code ontroert

De drie snippets die we vandaag hebben bekeken, zijn geen simpele 'programmeertips'.

Ze weerspiegelen de filosofie van Python: "Hoe kan ik mijn intentie duidelijker, beknopter en mooier uitdrukken?"

Code kan meer zijn dan alleen instructies voor machines; het kan ook een 'tekst' zijn die de denkwijze van de ontwikkelaar vastlegt. Goed geschreven code kan ons net zo goed verrassen als goed geschreven tekst.

Ik hoop dat jouw code ook vol zit met deze 'Pythonic verwondering'.