Abstractie in Python

Abstractie in softwareontwikkeling is vrij belangrijk omdat het ons in staat stelt om stukjes code te definiëren die op zichzelf werken met gedeelde complexiteit, vaak kunnen we abstracte functies gebruiken die van toepassing zijn op zoveel gevallen dat we ze kunnen gebruiken wanneer we maar willen.
Als we de programma's zien waarin we mogelijk hebben geschreven, Python Na de tutorials zien we dat het kleine programma's zijn met maximaal 15 tot 20 regels, maar als we een veel groter programma zouden willen schrijven, zou het een groot probleem zijn als we niet met abstractie omgaan. Onthoud dat de verdienste van de programmeur is dat hij geen onnodig werk doet, dat wil zeggen dat hij niet twee keer hetzelfde doet of zichzelf herhaalt.
Laten we de volgende code eens bekijken, deze berekent de eerste 10 cijfers van a Fibonacci-reeks:

 fibs = [0, 1] voor i binnen bereik (8): fibs.append (fibs [-2] + fibs [-1]) 

Dit resulteert effectief in de eerste 10 cijfers

Wat gebeurt er als we willen dat de gebruiker definieert dat het in plaats van 10 getallen een dynamische grootheid is, dan herconditioneren we onze code als volgt:

 fibs = [0, 1] num = invoer ('Hoeveel Fibonacci-nummers wil je?') voor i binnen bereik (num-2): fibs.append (fibs [-2] + fibs [-1]) print fibs 

Tot nu toe lijkt alles normaal, we zien geen technisch probleem, maar er is een probleem met de programmeerfilosofie, als we dit bijvoorbeeld in verschillende delen van een programma willen doen, moeten we al deze regels steeds opnieuw schrijven, dit zou zijn wat we onnodig werk noemen. Wat we abstractie noemen, is kortere code waarbij wat erachter gebeurt geïsoleerd is, zo gemaakt dat het overal werkt, dat we ons alleen zorgen maken over het verkrijgen van wat nodig is voor onze omstandigheden, een meer abstracte manier om de vorige codes te zien zou deze zijn:

 num = invoer ('Hoeveel getallen wil je?') print fibs (num) 

Laten we er rekening mee houden dat het volledig direct is, we vragen om invoer hoeveel getallen de gebruiker wil, dan printen we een resultaat, wat er gebeurt dat we ergens anders een fibs-functie hebben gedefinieerd waarmee we het kunnen oproepen wanneer we maar willen, waardoor de noodzaak wordt vermeden om de lus van berekening steeds opnieuw uit te voeren, waardoor ons programma leesbaarder en minder complex wordt.
Leesbaarheid is alles wanneer we een groot programma ontwikkelen, het beheer van systeembronnen en efficiëntie zijn ook belangrijk, maar hoe een programma te verbeteren als we het niet begrijpen bij het lezen, bijvoorbeeld deze code:

 page = download_page () freqs = compute_frequencies (pagina) voor woord, freq in freqs: print woord, freq 

Als we het lezen, weten we wat het doet en wat het zou moeten retourneren, dit is abstractie in zijn puurste staat, hoe de methoden en functies op dit punt werken, interesseert ons niet, nu als efficiëntie en resourcebeheer problematisch worden, werken we gewoon aan de functie en het programma zou niet worden beïnvloed, dus we zouden maar één keer werken.
Dit is alles voor deze tutorial, we hebben materiaal over om verder te denken en onze programmeursmentaliteit te verbeteren, zodat we onze code kunnen abstraheren en veel efficiënter kunnen werken.