Abstraktion i Python

Abstraktion i mjukvaruutveckling är ganska viktigt eftersom det tillåter oss att definiera kodbitar som fungerar på egen hand med gemensam komplexitet, många gånger kan vi använda abstrakta funktioner som gäller för så många fall att vi kan använda dem när vi vill.
Om vi ​​ser de program som vi kan ha skrivit i Pytonorm Efter handledningarna ser vi att de är små program med högst 15 till 20 rader, men om vi ville skriva ett mycket större program skulle det vara ett stort problem om vi inte hanterar abstraktion. Kom ihåg att programmerarens dygd är att han inte gör onödigt arbete, det vill säga att han inte arbetar samma sak två gånger eller upprepar sig själv.
Låt oss se följande kod, den beräknar de första 10 talen i a Fibonacci -sekvens:

 fibs = [0, 1] för i inom intervall (8): fibs.append (fibs [-2] + fibs [-1]) 

Detta resulterar effektivt i de första 10 siffrorna

Vad händer nu om vi vill att användaren ska definiera att istället för att vara 10 nummer är det en dynamisk kvantitet, då vill vi återkonditionera vår kod enligt följande:

 fibs = [0, 1] num = input ('Hur många Fibonacci-tal vill du ha?') för i inom intervallet (num-2): fibs.append (fibs [-2] + fibs [-1]) print fibs 

Hittills verkar allt normalt, vi ser inga tekniska problem, men det finns ett programmeringsfilosofiproblem, till exempel om vi vill göra detta i flera delar av ett program måste vi skriva alla dessa rader om och om igen, detta skulle vara vad vi kallar onödigt arbete. Det vi kallar abstraktion är kortare kod där det som händer bakom är isolerat, gjort på ett sådant sätt att det fungerar var som helst, att vi bara oroar oss för att få det som är nödvändigt för våra förhållanden, ett mer abstrakt sätt att se de tidigare koderna skulle vara detta:

 num = input ('Hur många nummer vill du ha?') print fibs (num) 

Låt oss notera att det är helt direkt, vi ber om inmatning hur många siffror användaren vill ha, sedan skriver vi ut ett resultat, som är vad som händer att vi har definierat en fib -funktion någon annanstans som gör att vi kan åberopa det när vi vill, undvika behovet att göra beräkningsöglan om och om igen, vilket gör vårt program mer läsbart och mindre komplext.
Läsbarhet är allt när vi utvecklar ett stort program, hantering av systemresurser och effektivitet är också viktigt, men hur man förbättrar ett program om vi inte förstår det när vi läser det, till exempel den här koden:

 sida = nedladdningssida () frekvenser = beräkningsfrekvenser (sida) för ord, frekvens i frekvenser: skriv ut ord, frekvens 

När vi läser den vet vi vad den gör och vad den ska returnera, detta är abstraktion i dess renaste tillstånd, hur metoderna och funktionerna fungerar vid denna tidpunkt inte intresserar oss, nu om effektivitet och resurshantering blir problematisk arbetar vi helt enkelt med funktion och programmet skulle inte påverkas, så vi skulle bara arbeta en gång.
Det här är allt för denna handledning, vi har material kvar för att fortsätta tänka och förbättra vår programmerarmentalitet, så att vi kan abstrahera vår kod och arbeta mycket mer effektivt.