Dat is dan ook de voornaamste reden om object-oriented programming in Python te leren, wat overigens ook \u00e9\u00e9n van de meest populaire programmeertalen is.<\/p>\n
Tijd om te gaan leren dus!<\/p>\n
Een voorbeeld van een Python programma<\/h2>\n
Voordat we de diepte in gaan, eerst een vraag: heb je wel eens een Python programma geschreven zoals het voorbeeld hieronder?<\/p>\n
secret_number = 20\n \nwhile True:\n number = input('Guess the number: ')\n \n try:\n number = int(number)\n except:\n print('Sorry that is not a number')\n continue\n \n if number != secret_number:\n if number > secret_number:\n print(number, 'is greater than the secret number')\n \n elif number < secret_number:\n print(number, 'is less than the secret number')\n else:\n print('You guessed the number:', secret_number)\n break\n<\/code><\/pre>\nDit is de code van een eenvoudig programma waarmee je een getal kan raden. Kopieer het maar naar een Python bestand en voer het uit op je computer. Het zal meteen en soepel werken.<\/p>\n
Maar nu een probleem: wat als we je vragen om een nieuwe feature<\/a> toe te voegen aan het programma? Dit kan iets simpels zijn, bijvoorbeeld:<\/p>\n“Als de input een veelvoud is van het geheime getal, geef de gebruiker dan een hint.”<\/p>\n
Het programma zal snel veel complexer worden naarmate je het aantal features vergroot, en het aantal geneste voorwaarden zal moeilijk te beheren zijn.<\/p>\n
En dat is precies het probleem dat object-oriented programming op kan lossen.<\/p>\n\n
Vereisten om Python OOP te leren<\/h2>\n
Voordat we in object-oriented programming duiken, raden we sterk aan dat je al een goede basis hebt in Python.<\/p>\n
Wat precies een “basis” is, is natuurlijk lastig te defini\u00ebren. Daarom hebben we een cheat sheet<\/a> gemaakt met alle belangrijkste concepten die je moet kennen om aan de slag te kunnen met object-oriented programming in Python.<\/p>\n\n- Variabele<\/strong>: Symbolische naam die naar een specifiek object verwijst (gedurende dit artikel zullen we leren wat objecten<\/strong> zijn).<\/li>\n
- Rekenkundige operators: <\/strong>Optelling (+), aftrekking (-), vermenigvuldiging(*), delen(\/), geheeltallig-delen(\/\/), modulo (%).<\/li>\n
- Ingebouwde data-types: <\/strong>Numeriek (integers, floats, complex), verzamelingen (strings, lists, tuples), Boolean (True, False), dictionaries, en sets.<\/li>\n
- Booleaanse uitdrukkingen: <\/strong>Uitdrukking waarvan het resultaat True<\/strong> of False<\/strong><\/li>\n
- Voorwaardelijk:<\/strong> Evalueert een Booleaanse uitdrukking en voert een proces uit op basis van het resultaat. Wordt geregeld via if\/else<\/strong><\/li>\n
- Loop: <\/strong>Ook wel lussen, zijn herhalende uitvoering van stukken code. Dit kunnen for<\/strong> of while<\/strong> loops zijn.<\/li>\n
- Functies: <\/strong>Blokken georganiseerde en herbruikbare code. Je kan ze via het keyword def<\/strong><\/li>\n
- Argumenten: <\/strong>Objecten die je aan een functie doorgeeft. Bijvoorbeeld:
sum([1, 2, 4])<\/code><\/li>\n- Uitvoeren van een Python script<\/strong>: Open een terminal of command line<\/a> en typ \u201cpython <bestandsnaam>.\u201d<\/li>\n
- Open een Python Shell<\/strong>: Open een terminal en typ
python<\/code> of python3<\/code>, afhankelijk van je systeem.<\/li>\n<\/ul>\nNu je deze concepten helder hebt, kunnen we doorgaan met het leren van object-oriented programming.<\/p>\n
Wat is object-oriented programming in Python?<\/h2>\n
Object-oriented programming (OOP) is een paradigma of methode voor programmeren waarbij we complexe problemen benaderen als objecten.<\/p>\n
Een methode of paradigma is een theorie die de basis biedt voor het oplossen van problemen.<\/p>\n
Wanneer we het dus hebben over OOP, hebben we het over een verzameling concepten en patronen waarbij we problemen oplossen via objecten.<\/p>\n
Een object in Python is een verzameling data (attributes) en gedrag (methods). Je kan objecten zien zoals veel tastbare dingen om je heen. Denk bijvoorbeeld aan een rekenmachine:<\/p>\n![\"Een](\"https:\/\/kinsta.com\/wp-content\/uploads\/2021\/06\/Kinsta-Objects-around-you.png\")
<\/a>Een rekenmachine kan een object zijn.<\/figcaption><\/figure>\nZoals je wellicht ziet zijn de data (attributen) altijd zelfstandige naamwoorden, en het gedrag (methode) wordt altijd beschreven door werkwoorden.<\/p>\n
Dit onderscheid is een centraal concept voor object-oriented programming. Je kan objecten bouwen waarin je data opslaat en die bepaalde functionaliteit bevatten.<\/p>\n
Waarom gebruiken we object-oriented programming in Python?<\/h2>\n
Met OOP kan je veilige en robuuste software bouwen. Veel Python frameworks en libraries<\/a> gebruiken dit paradigma om hun codebase te bouwen. Voorbeeld zijn Django, Kivy, pandas, NumPy, en TensorFlow.<\/p>\nWe kijken naar de belangrijkste voordelen van het gebruik van OOP in Python.<\/p>\n
Voordelen van OOP in Python<\/h3>\n
De volgende redenen zijn uitstekende argumenten om te kiezen voor object-oriented programming in Python.<\/p>\n
Alle moderne programmeertalen gebruiken OOP<\/h4>\n
Dit paradigma is onafhankelijk van de programmeertaal. Als je OOP in Python leert, zul je het ook kunnen toepassen op de volgende talen:<\/p>\n
\n- Java<\/li>\n
- PHP (lees ook onze vergelijking tussen PHP en Python<\/a>)<\/li>\n
- Ruby<\/li>\n
- Javascript<\/a><\/li>\n
- C#<\/li>\n
- Kotlin<\/li>\n<\/ul>\n
Al deze talen zijn van zichzelf object-oriented of bieden mogelijkheden voor object-oriented functionaliteit. Wil je na Python meer over die talen leren, dan is het dus makkelijker, omdat je veel overeenkomsten zult zien tussen verschillende programmeertalen die met objecten werken.<\/p>\n
Met OOP kan je sneller programmeren<\/h4>\n
Sneller programmeren betekent niet altijd minder regels code schrijven. Het betekent dat je meer features in minder tijd kan implementeren, zonder de stabiliteit in gevaar brengt.<\/p>\n
Object-oriented programming maakt het mogelijk om code te hergebruiken door het implementeren van abstractie<\/a>. Dit principe maakt je code beter te lezen en bondiger.<\/p>\nZoals je wellicht weet, zijn programmeurs<\/a> veel meer tijd kwijt aan het lezen van code dan aan het schrijven ervan. Dat is de reden dat leesbaarheid veel belangrijker is dan het zo snel mogelijk afmaken van features.<\/p>\n![\"Productiviteit](\"https:\/\/kinsta.com\/wp-content\/uploads\/2021\/06\/Kinsta-Not-legible-code.png\")
<\/a>Productiviteit neemt af bij slecht leesbare code<\/figcaption><\/figure>\nJe zal verderop meer lezen over het principe van abstractie.<\/p>\n
OOP helpt je om spaghetti-code te voorkomen<\/h4>\n
Herinner je je programma om getallen te raden van de inleiding van dit artikel?<\/p>\n
Als je features blijft toevoegen, heb je op een gegeven moment allemaal geneste if<\/strong> statements. Deze wirwar van code noemen we spaghetti-code, en dat moet je natuurlijk voorkomen.<\/p>\nOOP geeft de mogelijkheid om alle logica te comprimeren<\/a> in objecten, waardoor je allerlei geneste if<\/strong> statements kan voorkomen.<\/p>\nOOP verbetert je analyse en begrip van de situatie<\/h4>\n
Nadat je wat meer ervaring hebt met OOP, zul je sneller problemen kunnen onderscheiden in kleine en specifieke objecten.<\/p>\n
Hierdoor kan je sneller aan de slag met nieuwe projecten.<\/p>\n
Gestructureerd programmeren en object-oriented programming<\/h3>\n
Gestructureerd programmeren is het meestgebruikte paradigma voor beginners, omdat het de eenvoudigste manier is om een klein programma te bouwen.<\/p>\n
Hierbij voer je een Python programma in volgorde uit. Je geeft de computer dus een lijst met taken die van boven naar beneden uitgevoerd worden.<\/p>\n
Laten we eens kijken naar zo’n voorbeeld bij een programma voor een koffiebar.<\/p>\n
small = 2\nregular = 5\nbig = 6\n \nuser_budget = input('What is your budget? ')\n \ntry:\n user_budget = int(user_budget)\nexcept:\n print('Please enter a number')\n exit()\n \nif user_budget > 0:\n if user_budget >= big:\n print('You can afford the big coffee')\n if user_budget == big:\n print('It\\'s complete')\n else:\n print('Your change is', user_budget - big)\n elif user_budget == regular:\n print('You can afford the regular coffee')\n print('It\\'s complete')\n elif user_budget >= small:\n print('You can buy the small coffee')\n if user_budget == small:\n print('It\\'s complete')\n else:\n print('Your change is', user_budget - small)\n<\/code><\/pre>\nBovenstaande code werkt als de verkoper van een koffiebar. Je wordt gevraagd naar je budget, en wordt dan de grootst mogelijke koffie aangeboden die je kan betalen.<\/p>\n
Probeer het maar eens uit te voeren in de terminal<\/a>. Het zal stap voor stap uitgevoerd worden, op basis van je input.<\/p>\nDe code werkt perfect, maar er zitten drie nadelen aan:<\/p>\n
\n- Er zit veel herhalende logica in.<\/li>\n
- Er worden veel geneste if<\/strong> voorwaarden gebruikt.<\/li>\n
- Het is moeilijk te lezen en te bewerken.<\/li>\n<\/ol>\n
OOP is bedacht als oplossing voor al deze problemen.<\/p>\n
Laten we eens naar bovenstaand programma kijken, maar dan met OOP. Maak je geen zorgen als je het niet meteen begrijpt. We willen vooral het verschil tussen object-oriented programming en gestructureerd programmeren laten zien.<\/p>\n
class Coffee:\n # Constructor\n def __init__(self, name, price):\n self.name = name\n self.price = float(price)\n def check_budget(self, budget):\n # Check if the budget is valid\n if not isinstance(budget, (int, float)):\n print('Enter float or int')\n exit()\n if budget < 0: \n print('Sorry you don\\'t have money') \n exit() \n def get_change(self, budget):\n return budget - self.price\n \n def sell(self, budget):\n self.check_budget(budget)\n if budget >= self.price:\n print(f'You can buy the {self.name} coffee')\n if budget == self.price:\n print('It\\'s complete')\n else:\n print(f'Here is your change {self.get_change(budget)}$')\n\n exit('Thanks for your transaction')\n<\/code><\/pre>\nOpmerking<\/strong>: Alle volgende concepten worden verderop uitgelegd.<\/p>\nDe code hierboven definieert een class<\/strong> met de naam “Coffee”. Die class heeft twee attributen: “name” en “price”, die allebei gebruikt worden in de methoden. De primaire methode is “sell”, waarin alle logica voor het verkoopproces uitgevoerd wordt.<\/p>\nAls je die class probeert uit te voeren, krijg je echter geen output. Dat komt omdat we alleen het “template” voor de koffie bepalen, en niet de soorten koffie zelf.<\/p>\n
Die class kunnen we implementeren met de volgende code:<\/p>\n
small = Coffee('Small', 2)\nregular = Coffee('Regular', 5)\nbig = Coffee('Big', 6)\n \ntry:\n user_budget = float(input('What is your budget? '))\nexcept ValueError:\n exit('Please enter a number')\n \nfor coffee in [big, regular, small]:\n coffee.sell(user_budget)\n<\/code><\/pre>\nIn dit deel maken we instances<\/strong>, oftewel koffie-objecten, van de class “Coffee”, en gebruiken dan de “sell” methode van elke coffee, totdat de gebruiker aankomt bij een koffie die betaalbaar is.<\/p>\nWe krijgen met beide aanpakken dezelfde output, maar met OOP kunnen we het programma veel makkelijker uitbreiden.<\/p>\n
Hieronder een tabel met een vergelijking van object-oriented programming en gestructureerd programmeren:<\/p>\n
![\"Python](\"https:\/\/kinsta.com\/wp-content\/uploads\/2021\/06\/Python-terminal.png\")
<\/a>![\"Instances](\"https:\/\/kinsta.com\/wp-content\/uploads\/2021\/06\/Kinsta-Instances.png\")
<\/a>