Objektorientert programmering i Python

Mange funksjoner finnes i objektorientert programmering (OOP) for å utvikle en enkel til kompleks applikasjon. Den brukes til å organisere koden basert på objektet som inneholder attributter og atferd, og hvert objekt er en forekomst av en bestemt klasse. OOP -programmene er mer effektive enn funksjonell programmering og lett å forstå. Denne programmeringsmetoden er mer egnet for å utvikle store og komplekse prosjekter som er delt inn i grupper. Python er et veldig populært programmeringsspråk for å støtte både funksjonell og objektorientert programmering. Tre hovedtrekk ved OOP er arv, innkapsling og polymorfisme. Hvordan skrive et objektorientert program i Python fra Basic og bruken av tre hoved-OOP-funksjoner ved å bruke Python-skriptet har beskrevet i denne opplæringen.

Innhold:

Lære objektorientert programmering i Python fra det grunnleggende er blitt forklart her ved å diskutere følgende emner med eksempler.

1. Klasse og objekt
2. Konstruktør
3. Arv
4. Innkapsling
5. Polymorfisme
6. Getter og setter
7. Overbelastningsoperatør og funksjon

Klasse og objekt:

I objektorientert programmering, klasse brukes til å erklære den brukerdefinerte datastrukturen som inneholder settet med attributter. Attributtene kan være klassevariablene, forekomstvariabler og metoder. Variablene som er tilgjengelige etter alle tilfeller av klassen, kalles klassevariabler. Funksjonene som er deklarert i klassen kalles metoder. Variablene som er definert i en hvilken som helst klassemetode og tilgjengelige etter gjeldende forekomst av klassen kalles forekomstvariabler. En klasse er erklært i Python ved å definere klassens nøkkelord etterfulgt av et klassenavn og tykktarm (:). Syntaksen til klassen er definert nedenfor.

Syntaks av klassen:

Klassenavn:
Variabler;
Metoder;

En forekomst eller kopi av en klasse kalles en gjenstand brukes til å få tilgang til klassevariablene og klassemetodene. En klasse er ubrukelig uten å erklære et objekt fordi klasse Inneholder beskrivelsen av objektet bare som ikke tildeler noe minne. De gjenstand blir erklært ved å nevne klassenavnet med start og slutt på første parentes. Hvis klasse Inneholder hvilken som helst konstruktørmetode med parametrene, så må du definere verdien av parametrene på tidspunktet for gjenstand erklæring. Syntaksen til objektet er gitt nedenfor.

Syntaks av objektet:

Object_name = class_name ()

eller

Object_name = class_name (verdi1, verdi2, ...)

Erklæringen om en enkel klasse og objektdeklarasjonen i den klassen har vist i følgende skript. En klasse som heter 'Bok'har blitt erklært her som inneholder tre klassevariabler (boknavn, forfatternavn og pris) og en metode som heter book_discount_price (). Metoden vil beregne bokens pris etter 5% rabatt og skrive ut bokens detaljer med originalen og diskonteringsprisen. Objektvariabelen som heter Objbook er blitt definert i skriptet for å lage klassens forekomst og ringe klassemetoden.

ClassAndObject.py

# Definer klassen
Klassebok:
# Definer og initialiser klassevariabler
Book_name = "Lær Python The Hard Way"
forfatternavn = "Zed Shaw"
Pris = 22
# Definer klassemetode for å vise bokdetaljer med rabattpris
def book_discount_price (selv):
# Beregn rabattprisen etter 5% rabatt
d_price = selv.Pris - selv.Pris * 0.05
# Skriv ut bokdetaljer
print ("boknavn: \ nauthor navn: \ noriginal pris: $ \ ndiscount pris: $ \ n"
.Format (selv.boknavn, selv.forfatternavn, selv.Pris, D_Price))
# Lag et objekt i klassen
objbook = bok ()
trykk ("Bokinformasjon etter rabatt:")
# Ring klassemetoden
objbook.book_discount_price ()

Produksjon:

Følgende utgang vises etter å ha utført skriptet ovenfor.

Konstruktør:

Konstruktøren er en metode for en klasse som heter automatisk på tidspunktet for objektdeklarasjonen i den klassen. Det brukes hovedsakelig til å initialisere objektet til en variabel. def Nøkkelord brukes til å erklære enhver metode i en Python -klasse erklæring, og konstruktørmetodenavnet er __i det__() i Python. To typer konstruktører kan erklæres i Python. Dette er den parameterløse konstruktøren og parameterisert konstruktør. Bruken av begge konstruktører har vist i denne delen av denne opplæringen.

EN. Parameterfri konstruktør

Konstruktøren som bare inneholder ett argument som heter selv- kalles parameterfri eller standardkonstruktør. Det kreves ingen parameter for å passere på tidspunktet for objektdeklarasjon av en klasse som inneholder den parameterfri konstruktøren. Måten å erklære en parameterløs konstruktør er vist i følgende skript. Her, The Kunde Klassen inneholder den parameterfrie konstruktøren som initialiserer de fire klassevariablene når et hvilket som helst klasseobjekt opprettes. Neste, et objekt av klassen som heter Objcustomer har blitt erklært å få tilgang til variablene i klassen.

Standard_constructor.py

# Definer kundeklasse
Klassekunde:
# Erklære konstruktør uten parameter
def __init __ (selv):
# Initialiser klassevariabler
selv-.Id = 'D-67455'
selv-.Navn = 'Sakib Hasan'
selv-.konto_type = 'lagring'
selv-.Balanse = 5000000
# Opprett objekt for kundeklassen
objCustomer = kunde ()
Print ("Kundens grunnleggende informasjon: \ n")
# Skriv ut verdiene til objektegenskapene
print ("id: \ nname: \ naccount type: \ nbalance: "
.Format (objcustomer.Id, objcustomer.Navn, ObjCustomer.konto_type, objcustomer.balansere))

Produksjon:

Følgende utgang vises etter å ha utført skriptet ovenfor.

B. Parameterisert konstruktør

Konstruktøren som inneholder ett eller flere argumenter med 'selv-'Argument kalles den parameteriserte konstruktøren. Du må passere parameterverdiene på tidspunktet for objektopprettelsen av klassen. Måten å erklære parameterisert konstruktør er vist i følgende skript. Her, The Kunde Klasse er erklært med en parameterisert konstruktør og to metoder. Metoden som heter Balance_after_deposit () er definert for å legge til innskuddsbeløpet med saldoen. Metoden som heter Balance_after_withDraw () er definert for å trekke tilbaketrekningsbeløpet fra saldoen. Deretter er objektvariabelen definert for å vise kundens grunnleggende detaljer, balansen etter innskuddet og balansen etter tilbaketrekning.

parameterisert_constructor.py

# Definer kundeklasse
Klassekunde:
# Erklære konstruktør med parameter
def __init __ (self, cust_id, cust_name, cust_balance):
# Initialiser variabler
selv-.Id = cust_id
selv-.name = cust_name
selv-.Balanse = Cust_Balance
# Legg til beløp med balansen
def Balance_after_deposit (self, deposit_amount):
selv-.balanse += deposit_amount
# Skriv ut gjeldende saldo
PRINT ("Innskudd MMount: \ nCurrent Balance: \ n".Format (deposit_amount, selv.balansere))
# Trekk beløp fra balansen
def Balance_after_withDraw (self, tetraw_amount):
selv-.Balanse -= Uttak_amount
# Skriv ut gjeldende saldo
PRINT ("trekke ut Ammount: \ nCurrent Balance: \ n".Format (trekke ut_amount, selv.balansere))
# Opprett objekt for kundeklassen
ObjCustomer = kunde ('M-231234', 'Mir Sabbir', 200000)
# Skriv ut kundens grunnleggende informasjon
print ("Kundedetaljer: \ nid: \ nname: \ nopening balanse: \ n"
.Format (objcustomer.Id, objcustomer.Navn, ObjCustomer.balansere))
# Legg til innskuddsbeløpet
Objcustomer.Balance_after_deposit (30000)
# Trekk ut uttaksbeløpet
Objcustomer.Balance_after_withDraw (10000)

Produksjon:

Følgende utgang vises etter å ha utført skriptet ovenfor. Her er åpningsbalansen 200000. Balansen blir 220000 etter å ha lagt til 30000 og trukket 10000.

Arv:

En av de grunnleggende funksjonene ved objektorientert programmering er arv. Måten å lage en ny klasse fra en eksisterende klasse kalles arv. Den eksisterende klassen kalles foreldreklassen eller baseklassen, og den arvelige nye klassen kalles barnet eller avledet klasse. Barneklassen vil inneholde funksjonene i baseklassen etter arv. Hvordan arven kan brukes i Python -klassen har vist i følgende eksempel. I manuset, 'Student'er foreldreklassen, og'StudentDetails'Er barneklassen. Begge klasser har de parameteriserte konstruktørene. Foreldreklassen har en metode som heter Vis grunnleggende () For å skrive ut foreldreklassens ID, navn og e -postvariabler. Barneklassen har en metode som heter displayInfo () å skrive ut verdiene til parti og semestervariabler i barneklassen. Konstruktøren av foreldreklassen kalles barneklassekonstruktøren. Etter klasseerklæringen er objektet for foreldreklassen blitt erklært med tre-parameterverdier for å initialisere klassevariablene i foreldreklassen, og metoden til foreldreklassen er blitt kalt for å vise disse verdiene. Deretter er barneklasseobjektet blitt erklært med tre-parameterverdier for å initialisere klassevariablene i barneklassen, og metoden for barneklassen er blitt kalt for å vise disse verdiene.

arv.py

# Definer foreldreklassen
Klasseelev:
# Definer foreldreklassekonstruktøren
def __init __ (selv, id, navn, e -post):
# Initialiser variablene på foreldreklassen
selv-.Id = id
selv-.Navn = Navn
selv-.E -post = e -post
# Definer foreldreklassemetoden
def displaybasic (selv):
# Skriv ut verdiene til foreldreklassevariablene
print ("id: \ nname: \ nemail: ".Format (selv.Id, selv.Navn, selv.e -post))
# Definer barneklassen
klasse StudentDetails (student):
# Definer barneklassekonstruktør
def __init __ (selv, id, navn, e -post, avd., Batch, SEM, CGPA):
# Ring foreldreklassekonstruktøren
Student.__init __ (selv, id, navn, e -post)
# Initialiser barneklassevariablene
selv-.Avdeling = avd
selv-.batch = batch
selv-.Semester = SEM
selv-.CGPA = CGPA
# Definer barnets klassemetode
def displayInfo (selv):
Student.displaybasic (selv)
# Skriv ut verdiene til barneklassevariablene
print ("Avdeling: \ nbatch: \ nsemerter: "
.Format (selv.Avdeling, selv.batch, selv.semester))
# Lag gjenstanden for foreldreklassen
ObjStudent = Student ('674534', 'Rakib Hasan', '[email protected] ')
Print ("Studentens grunnleggende informasjon: \ n")
# Ring metoden i foreldreklassen
objstudent.DisplayBasic ()
# Lag gjenstanden for barneklassen
ObjStudentDetails = StudentDetails ('783412', 'Zannatul Ferdous', '[email protected] ',' cse ', 48, 10, 3.89)
print ("\ nstudents detaljinformasjon: \ n")
# Ring metoden for barneklassen
ObjStudentDetails.displayInfo ()
# Skriv ut en eiendomsverdi for barneklassen
Print ("CGPA: ".Format (objStudentDetails.CGPA))

Produksjon:

Følgende utgang vises etter å ha utført skriptet ovenfor.

Innkapsling:

Et annet grunnleggende trekk ved objektorientert programmering er innkapsling. Måten å skjule de spesielle variablene og metodene i en klasse kalles innkapsling. Det brukes til å angi begrensningen for tilgang til de aktuelle dataene. Hovedformålet med denne funksjonen er å gi datasikkerhet ved skjul av data. Innkapsling kan implementeres i Python ved å erklære de private eller beskyttede datamedlemmene i klassen. Hvordan innkapslingen kan implementeres i Python har vist i følgende eksempel. I manuset, Legg til Klassen har skapt ved å arve Antall klasse. Et privat medlem som heter '__resultat'har erklært i barneklassen for å lagre summen av to tall, og denne variabelen er kun tilgjengelig i barneklassen. Konstruktøren av foreldreklassen vil initialisere to klassevariabler med tallene. I følge manuset vil Child Class Constructor ringe foreldreklassens konstruktør, beregne summen av klassevariablene og skrive ut resultatet av tillegget. Etter klasseerklæringen er gjenstanden for barneklassen erklært. Deretter har det private medlemmet av barneklassen brukt i utskriftsfunksjonen som vil generere en feil.

innlevering.py

# Definer foreldreklassen
Klassenummer:
def __init __ (selv):
# Initialiser de offentlige medlemmene i foreldreklassen
selv-.N1 = 10
selv-.N2 = 30
# Definer barneklassen
Klasse tillegg (nummer):
def __init __ (selv):
# Ring foreldrekonstruktøren
Antall.__i seg selv)
""
Lagre resultatet av tillegget i et privat medlem
av barneklassen
""
selv-.__result = Selv.N1 + selv.n2
# Skriv ut resultatet av tillegget
print ("Resultatet av tillegget = \ n".Format (selv.__resultat))
# Lag gjenstanden for barneklassen
objadd = add ()
# Skriv ut den private eiendommen til barneklassen
trykk (objadd.__resultat)

Produksjon:

Følgende utgang vises etter å ha utført skriptet ovenfor. Da objektet ble definert, ble konstruktørmetoden kalt, og summen av 10 og 30 har skrevet ut. Feilmeldingen har dukket opp for å prøve å få tilgang til det private medlemmet fra utsiden av klassen.

Polymorfisme:

Et annet grunnleggende trekk ved objektorientert programmering er polymorfisme. Meningen med Poly er 'mange', og morfisme er 'former'. Måten å erklære den samme funksjonen flere ganger for forskjellige formål kalles polymorfisme. Kodingen blir lettere for å bruke denne funksjonen i OOP. Denne funksjonen kan implementeres ved hjelp av Python -skript, for eksempel polymorfisme i forskjellige klasser, polymorfisme i arvelige klasser osv. Hvordan polymorfismen kan implementeres i forskjellige klasser ved bruk av Python -skript har vist i følgende eksempel. I skriptet er det erklært to ikke -relaterte klasser som heter rektangel og sirkel. Begge klasser har den parameteriserte konstruktøren og en metode som er navngitt område(). Her inneholder begge klasser den samme metoden, men formålet med metoden er annerledes. I den rektangulære klassen vil konstruktøren initialisere to variabler som er navngitt høyde og bredde, og område() Metoden vil beregne området til rektangelet. I sirkelklassen vil konstruktøren initialisere en variabel som er navngitt radius, og område() Metoden vil beregne sirkelområdet. Etter å ha erklært klassen, vil to tallverdier bli hentet fra brukeren for å overføre høyde- og breddeverdiene til konstruktøren til Rektangel klasse på tidspunktet for objektdeklarasjon. Neste, The område() metode for Rektangel Klasse vil bli kalt for å skrive ut rektangelområdet basert på inngangsverdiene. Etter det vil en tallverdi bli hentet fra brukeren for å gi radiusverdien til konstruktøren til Sirkel klasse på tidspunktet for objektopprettelsen. , de område() metode for Sirkel Klasse vil bli kalt for å skrive ut sirkelområdet basert på inngangsverdien.

Polymorfisme.py

# Definer rektangelklassen
Klasse rektangel:
# Definer konstruktøren
def __init __ (selv, høyde, bredde):
# Initialiser klassevariablene
selv-.Høyde = høyde
selv-.bredde = bredde
# Definer metoden for å beregne rektangelområdet
Def Area (Self):
område = selv.Høyde * Selv.bredde
Print ("Rektangelets område er \ n".Format (område))
# Definer sirkelklassen
Klassesirkel:
# Definer konstruktøren
def __init __ (selv, radius):
# Initialiser klassevariabelen
selv-.Radius = radius
# Definer metoden for å beregne sirkelområdet
Def Area (Self):
Område = 3.14 * Selv.radius * selv.radius
Print ("Området til sirkelen er \ n".Format (område))
# Ta høyde- og breddeverdiene fra brukeren
høyde = int (input ("Angi høyden på rektangelet:"))
bredde = int (input ("Angi bredden på rektangelet:")
# Lag gjenstanden for rektangelklassen
Objrectangle = rektangel (høyde, bredde)
# Call Area () Metode for å skrive ut rektangelområdet
Objrectangle.område()
# Ta radiusverdien fra brukeren
Radius = int (input ("Angi radius for rektangelet:"))
# Lag gjenstanden for sirkelklassen
objcircle = sirkel (radius)
# Call Area () Metode for å skrive ut sirkelområdet
OB00000000000000000000000000000000000000000000000000000000000000000000000000000000 JCCRIRCS.område()

Produksjon:

Følgende utgang vises etter å ha utført skriptet ovenfor. I følge produksjonen har 5 tatt som høydeverdi, og 2 har tatt som breddeverdi. For disse verdiene er området til rectan0gle 10 (5 × 2) som er skrevet ut. Neste, 2 har tatt som radiusverdi, og sirkelområdet er 12.56 (3.14x2x2) som er skrevet ut.

Getter og setter:

Metoden som brukes til å lese eiendommens verdi kalles getter, og metoden som brukes til å angi eiendommens verdi kalles setter. I objektorientert programmering brukes getteren for å få tilgang til de private attributtene til klassen, og setteren brukes til å angi verdiene til de private attributtene til klassen. Hovedformålet med denne funksjonen er å sikre datainnkapsling og datavalidering. Getter og Setter kan implementeres ved å bruke normal funksjon eller @eiendom dekoratør. Begge måtene å implementere setter og getter har blitt vist i denne delen av opplæringen.

Setter og getter ved hjelp av normal funksjon:

Følgende skript viser hvordan den normale funksjonen kan brukes til å implanterte getter og setter -metoder. I manuset, Person Klassen inneholder de tilpassede getter- og settermetodene for å lese verdiene til de private klassevariablene og angi verdien av e -postvariabelen som er et privat medlem. Den tomme verdien har gått for e -postvariabelen på tidspunktet for oppretting av objekter, og den tilpassede settermetoden har blitt brukt til å angi verdien av e -posten. Den tilpassede getter -metoden vil returnere alle verdiene for klassevariabelen som en liste.

Custom_setter_Getter.py

# Definer klassen
Klasseperson:
def __init __ (selv, navn, e -post, telefon):
# Definer de private medlemsvariablene
selv-.__NAME = Navn
selv-.__Email = E -post
selv-.__Phone = Telefon
# Definer tilpasset getter
def get_person_data (selv):
Print ("Den tilpassede getter -metoden heter")
retur [selv.__navn, selv.__ -e -post, selv.__Phone]
# Definer tilpasset setter
def set_person_data (selv, e -post):
Print ("Den tilpassede settermetoden heter")
selv-.__Email = E -post
# Lag objektet i klassen
objperson = person ('rifat bin hasan', ", '01855435626')
# Angi e -postverdien ved å bruke tilpasset setter
Objperson.set_person_data ('[email protected] ')
# Les alle datamedlemmerverdier ved hjelp av tilpasset getter
person = objperson.get_person_data ()
# Skriv ut returverdiene
print ("Navn: \ nemail: \ nPhone: ".Format (person [0], person [1], person [2]))

Produksjon:

Følgende utgang vises etter å ha utført skriptet ovenfor.

Setter og getter ved hjelp av @property dekoratør:

Følgende skript viser hvordan @Property Decorator kan brukes til å implanterte getter og setter -metoder. I manuset har getteren og setteren erklært ved å bruke @property dekoratør for å angi navnevariabelenes verdi, et privat klassemedlem. Etter å ha erklært klassen, er objektet for klassen blitt definert, og verdien av navnevariabelen er tildelt og hentet ved å bruke setter og getter.

Decorator_setter_Getter.py

# Definer klassen
Klasseperson:
def __init __ (selv, navn = "):
# Definer de private medlemsvariablene
selv-.__NAME = Navn
# Definer tilpasset getter
@eiendom
def name (self):
Print ("Getter -metoden heter")
Returnerer selv.__Navn
# Definer tilpasset setter
@Navn.setter
def name (selv, navn):
Print ("Setter -metoden kalles")
selv-.__NAME = Navn
# Lag objektet i klassen
objperson = person ()
# Angi e -postverdien ved å bruke tilpasset setter
Objperson.Navn = 'Zanifer Ali'
print ("Navnet på personen er \ n".Format (Objperson.Navn))

Produksjon:

Følgende utgang vises etter å ha utført skriptet ovenfor.

Overbelastningsoperatør og funksjon:

Når noen funksjon eller operatør brukes til et annet formål basert på funksjonsparameteren eller operandene i stedet for normal bruk av funksjonen eller operatøren, kalles det overbelastning. Gjenbrukbarhetsfunksjonen kan implementeres i objektorientert programmering ved å bruke operatøroverbelastning og funksjonsoverbelastning. Det er en nyttig funksjon ved OOP, men overflødig bruk av denne funksjonen skaper vanskeligheter med å håndtere koden. Den enkle bruken av operatøroverbelastning og funksjonsoverbelastning i Python -klassen er vist i denne opplæringen.

Operatøroverbelastning:

Operatøren brukes på to operander. Formålet med hver operatør er forskjellig. For eksempel er det mange bruksområder av '+' -operatøren, for eksempel den kan brukes til tillegg, og kombinerer to strenger osv. Men når '+' -operatøren brukes til et annet formål, kalles det operatøroverbelastning. Spesialfunksjonene brukes til forskjellige typer overbelastning av operatør. Spesialfunksjonen er erklært ved hjelp av '__' i begynnelsen og avslutningen av funksjonsnavnet. Mange spesielle funksjoner av forskjellige typer operatører finnes i Python for overbelastning av operatør. Operatøren kan være matematisk, sammenligning operatør, Oppdragsoperatør, etc. Bruken av den spesielle funksjonen til den matematiske operatøren er vist i denne delen av denne opplæringen for å forstå konseptet overbelastning av operatøren i Python.

Matematisk operatør:

Operatørene som brukes til aritmetiske operasjoner kalles matematisk operatør. Disse operatørene kan brukes til et spesielt formål ved å bruke en spesiell funksjon. Noen spesielle funksjoner til den matematiske operatøren er nevnt nedenfor.

Operatørnavn	Symbol	Spesiell funksjon
Addisjon	+	__add __ (selv, annet)
Subtraksjon	-	__Sub __ (selv, annet)
Multiplikasjon	*	__mul __ (selv, annet)
Inndeling	/	__Truediv __ (selv, annet)
Modul	%	__mod __ (selv, annet)
Makt	**	__POW __ (selv, annet)

Bruke spesialfunksjonen til strømoperatør (**):

__POW __ () Spesiell funksjon brukes til å overbelaste strømoperatøren. Hovedformålet med strømoperatøren er å beregne strømverdien til et bestemt tall. Men hvis vi trenger å beregne effektverdiene ved å bruke punktverdier, vil den generelle strømoperatøren ikke fungere. Anta at det er to punkter (3, 2) og (2, 4). Vi trenger summen av 32 og 24. I dette tilfellet må vi bruke den spesielle funksjonen til strømoperatøren. __POW __ () -funksjonen kan beregne summen av kreftene basert på poengverdier vist i følgende skript. Klassen Sumofpower Inneholder en parameterisert konstruktør for å initialisere to klassevariabler, __POW __ () funksjon for å beregne summen av to krefter basert på punktverdier, og __str __ () Funksjon for å skrive ut objektet til klassen. Deretter er to objekter i klassen blitt erklært. Kraftoperatøren har brukt to objektvariabler i utskriften () funksjon for å kalle __POW __ () funksjon for å fullføre operasjonen.

operatør_overlasting.py

# Definer klassen
Klassesumofpowers:
# Definer klassekonstruktøren
def __init __ (self, n1, n2):
selv-.a = n1
selv-.B = N2
# Overbelastning av strømoperatøren
def __pow __ (selv, annet):
a = selv.en ** annen.en
B = Selv.bry.b
selv-.resultat = a + b
Returner SumOfpowers (A, B)
# strengfunksjon for å skrive ut objektet i klassen
def __str __ (selv):
Return Str (selv.a)+'+'+str (selv.b)
# Opprett det første objektet
POW1 = SumOfpowers (3, 2)
# Opprett det andre objektet
POW2 = SumOfpowers (2, 4)
# Beregn kreftene og skriv ut summen av krefter
Print ("Summen av Powers =", POW1 ** POW2, "=", POW1.resultat)

Produksjon:

Følgende utgang vises etter å ha utført skriptet ovenfor. 32 er 9, og 24 er 16. Summen av 9 og 16 er 25 som vises i utgangen.

Funksjon overbelastning:

Noen ganger må vi skrive flere metoder som bare er like, men bare forskjellige i noen deler. I dette tilfellet kan en enkelt metode defineres for å gjøre de samme oppgavene ved å bruke funksjonsoverbelastning. Kompleksiteten til koden kan fjernes, og koden blir tydeligere ved å bruke funksjonsoverbelastning. Utgangen fra funksjonen avhenger av argumentet som er gitt til funksjonen. Hvordan funksjonsoverbelastningen kan implementeres i Python har vist i følgende skript. Skriptets hovedformål er å utføre fire typer aritmetiske operasjoner med standardverdien eller verdiene som ble gitt på tidspunktet for objektoppretting. Metoden som heter regne ut () har blitt brukt her for å utføre aritmetiske operasjoner. Metoden er blitt kalt fire ganger i skriptet for å gjøre fire typer oppgaver. Når metoden ringer uten noe argument, vil den bare vise en melding. Når metoden ringer med '+' som argumentverdi, vil den beregne standardverdiene. Når metoden ringer med '-' og en numerisk verdi som argumentverdier, vil den trekke den andre standardverdien fra argumentverdien. Når metoden ringer med '*' og to numeriske verdier som argumentverdier, vil den beregne to argumentverdier.

funksjon_overlasting.py

# Definer klassen
Klasse aritmetikk:
# Definer klassevariabelen
Resultat = 0
# Definer klassemetoden
Def Calculat (Self, Operator = "", Number1 = 25, Number2 = 35):
# Beregn summeringen
Hvis operatør == "+":
selv-.Resultat = nummer1 + nummer2
trykk ('Resultatet av tillegget er '.Format (selv.resultat))
# Beregn subtraksjonen
ELIF operatør == "-":
selv-.Resultat = nummer1 - nummer2
Print ('Resultatet av subtraksjonen er '.Format (selv.resultat))
# Beregn multiplikasjonen
ELIF operatør == "*":
selv-.Resultat = nummer1 * nummer2
print ('Resultatet av multiplikasjonen er '.Format (selv.resultat))
# Beregn divisjonen
ELIF operatør == "/":
selv-.Resultat = nummer1 / nummer2
trykk ('Resultatet av divisjonen er '.Format (selv.resultat))
ellers:
trykk ("Ingen operatør er gitt")
# Lag gjenstanden for klassen
objaritmetikk = aritmetikk ()
# Ring metoden uten argument
Objaritmetikk.regne ut()
# Ring metoden med ett argument
Objaritmetikk.beregne ('+')
# Ring metoden med to argumenter
Objaritmetikk.beregne ('-', 50)
# Ring metoden med tre argumenter
Objaritmetikk.beregne ('*', 2, 3)

Produksjon:

Følgende utgang vises etter å ha utført skriptet ovenfor. 'Ingen operatør er gitt'Meldingen har skrevet ut for å ringe metoden uten noe argument. Summen av 25 og 35 er skrevet ut for å kalle metoden med ett argument. Subtraksjonsverdien på 50-35 er skrevet ut for å kalle metoden med to argumentverdier. Multiplikasjonsverdien på 3 og 2 har skrevet ut for å kalle metoden med tre argumentverdier. På denne måten er funksjonsoverbelastning implementert i skriptet for å bruke den samme funksjonen flere ganger.

Konklusjon:

Den grunnleggende objektorienterte programmeringen i Python er blitt forklart i denne opplæringen ved å bruke veldig enkle Python-eksempler. De vanligste funksjonene i OOP blir diskutert her for å hjelpe leserne til å kjenne veien for OOP i Python og i stand til å skrive Python -program ved hjelp av klasse og objekt.