Python - Objecten

In de Object georiënteerd programmeren, objecten zijn abstracte representaties van elementen, die we definiëren door hun attributen en die een reeks methoden hebben waarmee we deze attributen kunnen manipuleren en er toegang toe hebben.
bestaan 3 functies die ons de reden geven om onze eigen objecten te gebruiken in plaats van afhankelijk te zijn van de functies, bibliotheken en globals die de taal ons ter beschikking stelt, dit zijn:

• Polymorfisme: gebruik van dezelfde bewerkingen op verschillende objecten van verschillende klassen.

• inkapseling: zijn attributen verbergen voor entiteiten buiten het object, zodat het deze kan beschermen.

• Erfenis- Maak meer specifieke objecten die de basisattributen en -methoden van een meer algemene hogere klasse erven.

Deze term betekent dat het vele vormen heeft, dit betekent dat we bewerkingen kunnen uitvoeren die anders zullen werken, afhankelijk van het type of de klasse van het object. Laten we een eenvoudig voorbeeld nemen, laten we ons voorstellen dat we een winkelwagentje hebben, dan definiëren we hoe we de prijsgegevens en het gewenste product willen verkrijgen, zoals we in de volgende afbeelding zien dat we een tuple maken.

Wat zou er gebeuren als de functionaliteit van het winkelwagentje wordt uitgebreid en nu we met veilingen werken, zouden we op de een of andere manier de waarden moeten specificeren die moeten worden ontvangen en hoe te handelen bij gebruik van dezelfde methoden, zoals velen zouden denken is om een ​​functie te maken van de volgende vorm, is echter niet geschikt.

Zoals we in de afbeelding kunnen zien, behandelen we de mogelijkheden van het moment, maar wat er gebeurt als de functionaliteiten worden vergroot, we zullen deze code voor altijd moeten blijven bijwerken, dat is waar het polymorfisme binnenkomt en wat we doen is definiëren dat elke object retourneert zijn prijs, ongeacht hoe deze wordt berekend, omdat het iets is dat intern is voor elke klasse, wat als volgt zou zijn:

We kunnen dan zien dat het iets is dat ons helpt om een ​​code te hebben die in de loop van de tijd duurzamer is en gemakkelijker te onderhouden.
Deze bestaat uit het verbergen van de interne details van de klas voor de buitenwereld, zodat het alleen toegankelijk is voor zijn eigen objecten en methoden, op deze manier kunnen we met klassen werken zonder hun interne werking te kennen, waardoor de complexiteit van de implementatie wordt geëlimineerd en de logica binnen onze objecten wordt beschermd.
Het stelt ons ook in staat werken met de zekerheid dat de gegevens binnen ons object niet worden gewijzigd, omdat als ze op een abstracte manier werken, we meerdere keren kunnen instantiëren en elke instantie volledig individueel is.
Laten we eens kijken naar een voorbeeld van een object dat niet is ingekapseld:

Hier zien we dat ook al was het o1 die een reeks van de naam heeft gemaakt, o2 toegang krijgen tot dezelfde naam zonder deze in te stellen, dit zou in een toepassing problematisch zijn, laten we ons voorstellen dat we de prijs van verschillende producten nodig hebben en dat elk de prijs van de vorige overschrijft.
Laten we nu, met een inkapseling, eens kijken hoe de hele stroom van het programma zou werken.

Hier zien we dat elk object zijn naam behoudt, zodat we weten dat we veilig kunnen werken door de juiste waarden voor elk van onze objecten te verkrijgen.