Programarea orientată pe obiecte (OOP) în Python

Până acum, programarea pe care ați făcut-o a fost procedurală. Cu toate acestea, o mulțime de programe astăzi sunt orientate pe obiecte. Cunoașterea ambelor tipuri și cunoașterea diferenței este foarte importantă. Multe limbaje importante din informatică, cum ar fi C++ și Java, folosesc adesea metode OOP.

Începătorii și non-programatorii găsesc adesea conceptul de OOP confuz și complicat. Acest lucru este normal. Nu te lăsa dezamăgit dacă te chinui sau nu înțelegi. Există o mulțime de alte resurse pe care le puteți folosi pentru a ajuta la depășirea oricăror probleme pe care le puteți avea, dacă acest capitol nu vă ajută.

Acest capitol va fi împărțit în diferite lecții. Fiecare lecție va explica OOP într-un mod diferit, doar pentru a vă asigura că OOP este acoperit cât mai bine posibil, deoarece ESTE FOARTE IMPORTANT. Înainte de lecții, există o introducere care explică conceptele cheie, termenii și alte domenii importante ale OOP, necesare pentru înțelegerea fiecărei lecții.

Gândiți-vă la o procedură ca la o funcție. O funcție are un scop specific. Acest scop poate fi colectarea de date, efectuarea de calcule matematice, afișarea datelor sau manipularea datelor către, din sau într-un fișier. De obicei, procedurile folosesc date care sunt separate de cod pentru manipulare. Aceste date sunt adesea transmise între proceduri. Când un program devine mult mai mare și complex, acest lucru poate cauza probleme. De exemplu, ați proiectat un program care stochează informații despre un produs în variabile. Atunci când un client solicită informații despre un produs, aceste variabile sunt transmise diferitelor funcții în scopuri diferite. Mai târziu, pe măsură ce mai multe date sunt stocate pe aceste produse, decideți să stocați informațiile într-o listă sau dicționar. Pentru ca programul dvs. să funcționeze, acum trebuie să editați fiecare funcție care a acceptat variabile, pentru a accepta și manipula o listă sau dicționar. Imaginați-vă timpul care ar dura pentru un program care avea sute de megaocteți și sute de fișiere în dimensiune! Te-ar înnebuni! Ca să nu mai vorbim că erorile din codul dvs. sunt aproape garantate, doar din cauza volumului mare de muncă și a posibilităților de a face o greșeală de tipar sau altă eroare. Acest lucru este mai puțin decât optim. Programarea procedurală este centrată pe proceduri sau funcții. Dar, OOP este centrat pe crearea de obiecte. Vă amintiți cum un program procedural are date separate și codul? Îți amintești cum acel program uriaș era format din sute de fișiere și că ar trebui să fie editat pentru totdeauna? Ei bine, gândiți-vă la un obiect ca la un fel de „combinație” a acelor fișiere și date într-o singură „ființă”. În sens tehnic, un Obiect este o entitate care conține date, ȘI proceduri (cod, funcții etc.).

Datele din interiorul unui obiect se numesc atribut de date.

Funcțiile sau procedurile din interiorul obiectului sunt numite metode.

Gândiți-vă la atributele datelor ca la variabile.

Gândiți-vă la metode ca la funcții sau proceduri.

Să ne uităm la un exemplu simplu, de zi cu zi. Întrerupătorul de lumină și becul din dormitorul tău. Atributele datelor ar fi următoarele:

light_on (adevărat sau fals)
switch_position (sus sau jos)
electricity_flow (adevărat sau fals)

Metodele ar fi următoarele

move_switch
change_electricity_flow

Atributele datelor pot fi sau nu vizibile. De exemplu, nu puteți vedea direct electricitatea care curge către bec. Știi doar că există electricitate, pentru că becul este aprins. Cu toate acestea, puteți vedea poziția comutatorului (switch_position) și puteți vedea dacă lumina este aprinsă sau stinsă (light_on). Unele metode sunt private. Aceasta înseamnă că nu le puteți schimba direct. De exemplu, dacă nu tăiați firele din corpul dvs. de iluminat (vă rugăm să nu faceți asta și, de dragul acestui exemplu, presupuneți că nu știți că firele există), nu puteți modifica direct fluxul de electricitate. De asemenea, nu puteți schimba direct dacă lumina este aprinsă sau stinsă (și nu, nu puteți deșuruba becul! lucrați cu mine aici!). Cu toate acestea, puteți schimba indirect aceste atribute folosind metodele din obiect. Dacă nu vă plătiți factura, metoda change_electricity_flow va schimba valoarea atributului electricity_flow la FALSE. Dacă apăsați comutatorul, metoda move_switch schimbă valoarea atributului light_on.

Până acum probabil te gândești: „Ce legătură are asta cu Python?” sau, „Înțeleg, dar cum se codifică un obiect?” Ei bine, suntem aproape în acel punct! Încă un concept trebuie explicat înainte de a ne putea cufunda în cod.

În Python, atributele și metodele de date ale unui obiect sunt specificate de o clasă. Gândiți-vă la o clasă ca la un plan pentru un obiect. De exemplu, casa dvs. – obiectul în care locuiți – îl puteți numi și pad, bungalou, pătuț sau orice altceva, a fost construit pe baza unui set de planuri; aceste planuri ar fi considerate clasa folosită pentru a vă proiecta casa, patul, pătuțul, ahem, ați înțeles ideea.

Din nou, o clasă ne spune cum să facem un obiect. În termeni tehnici, și acest lucru este important aici, o clasă definește atributele și metodele de date din interiorul unui obiect.

Pentru a crea o clasă, codificăm o definiție de clasă. O definiție de clasă este un grup de instrucțiuni care definesc atributele și metodele de date ale unui obiect.

Lecția unu

Mai jos este un program procedural care efectuează calcule matematice simple pe un singur număr, introdus de un utilizator.


# Program de Mitchell Aikens
# Fără Copyright
# 2012

# Procedura 1
def main():
    try:
        # Obțineți un număr de manipulat
        num = float(input("Please enter a number to manipulate.\n"))
        # Stocați rezultatul valorii, după ce a fost manipulat
        # de Procedura 2
        addednum = addfive(num)
        # Stocați rezultatul valorii, după ce a fost manipulat
        # de Procedura 3
        multipliednum = multiply(addednum)
        # Trimiteți valoarea la Procedura 4
        display(multipliednum)
    # Tratează cu excepțiile de la introducerea utilizatorului non-numerică
    except ValueError:
        print("You must enter a valid number.\n")
        # Resetați valoarea num, pentru a șterge datele non-numerice.
        num = 0
        # Apelați main, din nou.
        main()

# Procedura 2
def addfive(num):
    return num + 5

# Procedura 3
def multiply(addednum):
    return addednum * 2.452

# Procedura 4
def display(multi):
    # Afișați valoarea finală
    print("The final value is ",multi)

# Apelați Procedura 1
main()

Dacă ar fi să introducem o valoare de „5”, rezultatul ar fi așa cum se arată mai jos.

Please enter a number to manipulate.
5
The final value is  24.52

Dacă ar fi să introducem o valoare de „g”, apoi să corectăm intrarea și să introducem o valoare de „8”, rezultatul ar fi așa cum se arată mai jos.

Please enter a number to manipulate.
g
You must enter a valid number.

Please enter a number to manipulate.
8
The final value is  31.875999999999998

Mai jos, este o clasă și un program care folosește acea clasă. Acest program orientat pe obiecte face același lucru ca și programul procedural de mai sus. Să acoperim câteva concepte importante de codificare OOP înainte de a ne aprofunda în clasă și program. Pentru a crea o clasă, folosim cuvântul cheie class. După cuvântul cheie, tastați numele pe care doriți să-l denumiți pentru clasa. Este o practică obișnuită ca numele clasei dvs. să folosească convenția CapWords. Dacă aș vrea să creez o clasă numită dirtysocks, codul ar fi:


class DirtySocks

Clasa este afișată mai întâi. Programul care folosește clasa este al doilea.


# Nume fișier: oopexample.py
# Mitchell Aikens
# Fără Copyright
# 2012
# OOP Demonstrație - Class

class NumChange:

    def __init__(self):
        self.__number = 0

    def addfive(self,num):
        self.__number = num
        return self.__number + 5

    def multiply(self,added):
        self.__added = added
        return self.__added * 2.452

Programul care folosește clasa de mai sus este mai jos.


# Nume fișier: oopexampleprog.py
# Mitchell Aikens
# Fără Copyright
# 2012
# OOP Demonstrație - Program

import oopexample

maths = oopexample.NumChange()

def main():

    num = float(input("Please enter a number.\n"))

    added = maths.addfive(num)

    multip = maths.multiply(added)

    print("The manipulated value is ",multip)

main()

După ce te uiți la acel program, probabil că ești puțin pierdut. Asta e ok. Să începem prin a diseca clasa. Clasa se numește „NumChange” Există trei metode pentru această clasă:

__init__
addfive
multiply

Aceste trei metode au fiecare un cod similar.


def __init__(self):
def addfive(self,num):
def multiply(self,added):

Observați cum fiecare metodă are un parametru numit „self”. Acest parametru trebuie să fie prezent în fiecare metodă a clasei. Acest parametru NU TREBUIE să fie numit „self”, dar este o practică standard, ceea ce înseamnă că probabil ar trebui să rămâneți cu el. Acest parametru este necesar în fiecare metodă, deoarece atunci când o metodă se execută, trebuie să știe pe ce atribute ale obiectului să opereze. Chiar dacă există un singur obiect, trebuie totuși să ne asigurăm că interpretorul știe că dorim să folosim atributele de date din acea clasă. Așa că jucăm în siguranță… și folosim parametrul „self”.

Să ne uităm la prima metodă.


def __init__(self):

Majoritatea claselor din Python au un __init__ care se execută automat atunci când o instanță a unei clase este creată în memorie. (Când facem referire la o clasă, este creată o instanță [sau obiect] a acelei clase.) Această metodă este denumită în mod obișnuit metoda de inițializare. Când metoda se execută, parametrul „self” este atribuit automat obiectului. Această metodă este numită metoda de inițializare deoarece „inițializează” atributele datelor. În metoda __init__, setăm inițial valoarea atributului număr la 0. Facem referire la atributul obiectului folosind notația punct.


def __init__(self):
    self.__number = 0

Linia self.__number = 0 înseamnă pur și simplu „„valoarea atributului „number”, în obiect, este 0””.

Să ne uităm la următoarea metodă.


def addfive(self,num):
    self.__number = num
    return self.__number + 5

Această metodă se numește „addfive”. Acceptă un parametru numit „num”, din programul care utilizează clasa. Metoda atribuie apoi valoarea acelui parametru atributului „number” din interiorul obiectului. Metoda returnează apoi valoarea „number”, cu 5 adăugat la ea, instrucțiunii care a numit metoda.

Să ne uităm la a treia metodă.


def multiply(self,added):
    self.__added = added
    return self.__added * 2.453

Această metodă se numește „multiply”. Acceptă un parametru numit „added”. Acesta atribuie valoarea parametrului atributului „added” și returnează valoarea atributului „added” înmulțită cu 2,452, instrucțiunii care a numit metoda.

Observați cum numele fiecărei metode începe cu două caractere de subliniere? Să explicăm asta. Mai devreme am menționat că un obiect operează pe atribute de date din interiorul său folosind metode. În mod ideal, aceste atribute de date ar trebui să poată fi manipulate NUMAI PRIN METODE ÎN OBIECT. Este posibil ca codul exterior să manipuleze atributele datelor. Pentru a „ascunde” atributele, astfel încât numai metodele din obiect să le poată manipula, folosiți două caractere de subliniere înaintea numelui obiectului, așa cum am demonstrat. Omiterea acestor două caractere de subliniere în numele atributului permite posibilitatea manipulării din codul din afara obiectului.

Să ne uităm la programul care folosește clasa pe care tocmai am disecat-o.

Observați prima linie a codului fără comentarii.


import oopexample

Această linie de cod importă clasa, pe care am salvat-o într-un fișier separat (modul). Clasele nu trebuie să fie într-un fișier separat, dar este aproape întotdeauna cazul și, prin urmare, este o practică bună să vă obișnuiți să importați modulul acum.

Următoarea linie:


maths = oopexample.NumChange()

Această linie creează o instanță a clasei NumChange, stocată în modulul numit „oopexample”, și stochează instanța în variabila numită „maths”. Sintaxa este: modulename.Classname() În continuare definim funcția principală. Apoi, primim un număr de la utilizator.

Următoarea linie added = maths.addfive(num) trimite valoarea variabilei „num” la metoda numită „addfive”, care face parte din clasa pentru care am stocat o instanță în variabila numită „maths” și stochează valoarea returnată în variabila numită „added”.

Următoarea linie multip = maths.multiply(added) trimite valoarea variabilei „added”, la metoda numită „multiply”, care face parte din clasa pentru care am stocat o instanță în variabila numită „maths”, și stochează valoarea returnată în variabila numită „multip”.

Următoarea linie afișează „The manipulated value is <value of multip>”. Ultima linie apelează funcția principală care execută pașii descriși mai sus.

(Include texte din Wikibooks traduse și adaptate de Nicolae Sfetcu)