In de vorige video hebben we geleerd dat Opie is wat we een paradigma noemen, een manier om na te denken over onze code
en structuur, onze code.
En ik ga een link maken naar dit uitstekende artikel van Wikipedia over de geschiedenis van programmeertalen.
Zie je, we zijn begonnen met basisprogrammeertalen.
We hebben dingen als assembler die erg laag was, heel dicht bij machinecode.
We hadden dingen als Kobel en toen we langzaamaan meer en meer code begonnen te schrijven in de jaren '60 en
'70, begonnen we enkele van deze fundamentele paradigma's vast te stellen.
En een van de grote paradigma's die ontstonden, vooral met de programmeertaal
smalltalk, was dit idee van objectgeoriënteerd programmeren of een objectgeoriënteerde taal.
Zie je, tot dat moment schreven we wat we procedurele code noemen.
Wat dat betekent is dat als we bijvoorbeeld naar een python-bestand kijken, een procedurecode net een procedure
was.
We hadden gewoon lijnen één tot en met, laten we zeggen honderd, en we gingen gewoon van de bovenkant van de
lijn naar de onderkant van de lijn, we hadden conditionals, misschien loops, maar alles was doe dit, doe dat.
Wij waren het die tegen de machine zeiden, hé, doe gewoon precies.
Dat is wat ik je ga vertellen met de introductie van objectgeoriënteerde paradigma's.
Dit veranderde een beetje, we begonnen te zeggen, hey, laten we iets in onze code modelleren dat een object uit de echte
wereld vertegenwoordigt.
Als ik bijvoorbeeld op het punt sta een auto te coderen, zou ik een auto-object maken met gegevens over welke kleur het
is, welk type motor het heeft, hoeveel stoelen het heeft, maar ook acties zoals methoden die we
kunnen nemen erop, zoals de auto vooruit kan gaan, hij kan achteruit gaan, hij kan de deur openen.
En in plaats van deze regel voor regel procedurele code te hebben, kunnen we denken in
termen van modellen, echte blauwdrukken, omdat we als mensen dingen organiseren, denken aan een kamer, denken aan een
fabriek door dingen te organiseren en verschillende groepen in een specifieke locatie samenwerken.
Dat is een betere manier om te denken en dingen te regelen.
Dus hoe zou dit eruit zien in Python?
Nou, Python is een objectgeoriënteerde taal, of Cambie, wat betekent dat het in staat is om opioïden te ondersteunen, dit idee van objecten
en modellering en we hebben dit gezien wanneer we het type gebruiken, we zien dat alles een
object is omdat we dit gebruiken klasse trefwoord.
Maar wat is dit class-sleutelwoord in Python?
Ik kan mijn eigen gegevens maken, mijn eigen klas typen door gewoon klas te zeggen, en daarna kan ik het een naam geven die
ik wil.
Laten we zeggen klasse.
Groot.
Voorwerp.
Nu zie je meteen dat de naamgevingsconventie anders is dan wat we eerder hebben gezien.
We gaan ervoor zorgen dat het een hoofdletter krijgt, wat de standaard is die we programmeurs willen laten weten dat dit
een klasse gaat worden en we gebruiken de slang niet.
We gebruiken wat we Comikaze noemen, wat elk nieuw woord is, een hoofdletter is.
En dan gebruiken we hier de Callon en dan schrijven we hier onze code.
Ik ga de code nu niet schrijven, ik sla gewoon over.
Maar daar heb ik zojuist een nieuwe klas gemaakt, zodat als ik dat doe, laten we zeggen, bijvoorbeeld.
Type.
Groot object en ik klik op uitvoeren.
Nou, ik krijg nog steeds type, want op dit moment hebben we deze klasse gemaakt, wat een blauwdruk is, maar
we hebben het object niet echt gemaakt.
Ik weet dat de formulering verwarrend kan zijn, maar heb geduld.
Ik zal dit uitleggen.
We kunnen nu maken, laten we zeggen dat object één gelijk is aan twee grote objecten.
En dan deze klas leiden.
Dus als ik hier object typ, object één en ik klik op uitvoeren.
Ik krijg klasse, groot object.
Je kunt de belangrijkste hier voor nu negeren, omdat we er later over gaan praten, maar je ziet hier dat
ik zojuist mijn eigen object heb gemaakt.
Laten we nu eens nadenken over wat hier net is gebeurd, want het is veel om te begrijpen.
Je ziet een objectgeoriënteerde programmering, er is een idee van een klasse en een object, nu is een klasse dit,
het is de blauwdruk, de blauwdruk van wat we willen creëren.
Wat zijn de basiskenmerken?
Dat zijn eigenschappen die onze klas heeft?
Wat zijn enkele basismethoden of acties die onze klas kan ondernemen?
En vanuit deze blauwdruk kan ik keer op keer verschillende objecten maken en dit als bouwsteen
gebruiken.
Dus deze blauwdruk is wat we een klas noemen.
Die we definiëren met het sleutelwoord, en deze klasse kan worden geïnstantieerd, dat is de actie van het maken
van verschillende instanties.
En wat zijn deze gevallen?
Dit zijn allemaal objecten.
Nu, de naamgeving hier is iets waar je aan zult moeten wennen,
en alle objectgeoriënteerde programmeertalen hebben deze taal, dus je zult gewoon moeten begrijpen wat iemand zegt,
hey, ik heb net een klas geïnstantieerd.
Het betekent, hé, ik heb zojuist een nieuwe instantie gemaakt, een nieuw object.
Dus als we naar dit diagram kijken, gaan we terug naar de code die we zojuist hebben geschreven, we hebben hier een klasse of
een blauwdruk gemaakt.
En dan hier, deze dubbele haak zijn wij die de klasse instantiëren en zeggen, hey, klasse, gebruik wat je hier ook
hebt en instantiëren het en maak een nieuw object.
We maken dus een nieuw object door deze klasse te instantiëren.
En dit is precies wat we doen met zoiets als een lijst, toch?
Ik kan meerdere lijsten keer op keer maken, en elke keer dat ik een lijst maak, heb
ik toegang tot al deze methoden en soms zelfs attributen die ik kan gebruiken.
En op deze manier bespaar ik veel tijd in plaats van het zelf te coaten en op dezelfde manier kan ik
hier meerdere objecten aan toevoegen.
Voorwerp drie.
Zo maar, en nu heb ik drie verschillende objecten die ik kan gebruiken op basis van deze blauwdruk.
De blauwdruk heeft op dit moment niets, want ik kan hier later code toevoegen en dat gaan we in
de volgende video doen.
Maar het mooie is, laten we eens nadenken over efficiëntie.
Hier zie je de blauwdruk zelf.
De klas wordt in het geheugen opgeslagen.
Dus de Python-interpreter gaat zeggen, hé, groot object.
Het wordt de blauwdruk hiervoor.
Dus ik ga al die code in het geheugen opslaan.
Maar elke keer dat ik een object maak, hoef ik de code niet te herschrijven of iets dergelijks te doen.
Ik kan gewoon zeggen, hé, ga in het geheugen naar waar het grote object is en voer die code gewoon uit, zodat
we onze code opnieuw droog houden.
We hebben één plek waar we onze code in objecten kunnen instantiëren.
Laten we een pauze nemen en in de volgende video op deze les ingaan.