Introduktion til Python-overbelastning
Overbelastning er processen med at have det samme navn for mere end en enhed (metoder, operatører osv.), Men de adskiller sig efter deres attributter. Forskellen i attributter kan skyldes en forskel i en optælling af attributterne eller forskellen i typen af attributter. Med andre ord fra enhedens (metoder, operatører osv.) Perspektiv kan det udarbejdes eller forklares som en enheds evne til at opføre sig forskelligt i henhold til de parametre, der er matet til den. I python som i de fleste andre programmeringssprog på højt niveau kan overbelastningen af python opnås på to måder eller tilfælde, de er anført nedenfor,
- Overbelastning af funktioner eller metoder (Funktion Overbelastning).
- Overbelastning af operatører (Operator Overloading).
Funktion Overbelastning i Python
Overbelastning af metoder er ikke et anvendt koncept i python, men det kan opnås gennem flere teknikker. Først og fremmest kan begrebet overbelastning af metoden klassificeres i to forskellige koncepter,
- Overbelastning af brugerdefinerede funktioner.
- Overbelastning af standardfunktioner.
1. Overbelastning af brugerdefinerede funktioner
Brugerdefineret funktionsoverbelastning kan opnås i python ved at indstille en parameter eller argumentværdi som ingen. Så hvis et argument er indstillet som ingen, reagerer funktionen på en måde, når en værdi ikke er videregivet for dette argument, og på en anden måde, når en værdi ikke er videregivet for det samme argument.
Eksempel:
#!/usr/bin/env python
class Overloading_test:
def overloading_function(self, argument1 = 0, argument2 = 0 ):
if argument1 is not None or argument2 is not None:
print('Method Overloading parameter count :', (int( argument1) + int(argument2)))
else:
print( ' Method Overloading without parameters ' )
# Create instance
object1 = Overloading_test()
# Call the method with no arguments
object1.overloading_function()
# Call the method with 1 argument
object1.overloading_function(1)
# Call the method with 2 argument
object1.overloading_function(1, 1)
Produktion:
2. Overbelastning af standard- eller foruddefinerede funktioner
Overbelastning indbyggede funktioner involverer at definere den foruddefinerede funktion, som forventes at blive overbelastet i pythonklassen som en særlig funktion. Så når den foruddefinerede funktion erklæres som en speciel funktion i pythonklassen, bruger tolken denne specielle funktion som erklæring for det foruddefinerede opkald. Nedenstående eksempel forklarer denne proces nøjagtigt.
Eksempel:
lad os overveje len () -funktionen, der bruges til at bestemme længden på en vare til dette eksempel, nedenstående eksempel viser standardanvendelse af længdefunktionen uden at antyde overbelastning og lægger den tilsvarende påvirkning.
# Using len() function without method overloading
Lower_Case = ( ' a ', ' b ', ' c ', ' d ', ' e ', ' f ', ' g ', ' h ', ' i ', ' j ', ' k ', ' l ', ' m ', ' n ', ' o ', ' p ', ' q ', ' r ', ' s ', ' t ', ' u ', ' v ', ' w ', ' x ', ' y ', ' z ' ) Upper_Case = ( ' A ', ' B ', ' C ', ' D ', ' E ', ' F ', ' G ', ' H ', ' I ', ' J ', ' K ', ' L ', ' M ', ' N ', ' O ', ' P ', ' Q ', ' R ', ' S ', ' T ', ' U ', ' V ', ' W ', ' X ', ' Y ', ' Z ' ) print(' Collection used for List1 : ', type(Lower_Case))
print(' Collection used for list2 : ', type(Upper_Case))
print(' Total count of Alphabets in list1 : ', len(Lower_Case))
print(' Total count of Alphabets in list2 : ', len(Upper_Case))
Produktion:
Lad os nu bruge metodeoverbelastning til len () -funktionen i det samme kodestykket
class overloading:
def __init__(self, argument1, argument2):
self.argument1 = argument1
self.argument2 = argument2
def __len__(self):
return argument1+argument2
Lower_Case = ( ' a ', ' b ', ' c ', ' d ', ' e ', ' f ', ' g ', ' h ', ' i ', ' j ', ' k ', ' l ', ' m ', ' n ', ' o ', ' p ', ' q ', ' r ', ' s ', ' t ', ' u ', ' v ', ' w ', ' x ', ' y ', ' z ' ) Upper_Case = ( ' A ', ' B ', ' C ', ' D ', ' E ', ' F ', ' G ', ' H ', ' I ', ' J ', ' K ', ' L ', ' M ', ' N ', ' O ', ' P ', ' Q ', ' R ', ' S ', ' T ', ' U ', ' V ', ' W ', ' X ', ' Y ', ' Z ' ) print(' Collection used for List1 : ', type(Lower_Case))
print(' Collection used for list2 : ', type(Upper_Case))
argument1 = len(Lower_Case)
argument2 = len(Upper_Case)
# Using len() function without method overloading
Object1 = overloading(argument1, argument2)
print('Overall length of both the lists : ', len(Object1))
Produktion:
Vi kan tydeligt bemærke i stedet for at bruge den sædvanlige indbyggede længde-funktionalitet, hvor den overbelastede specialfunktion __len __ () bruges, hvilket får output til at udskrive den summerede længde på begge lister i stedet for deres individuelle længde.
Operatør Overbelastning i Python
Dette involverer en udvidet fortolkning af en operatør mere end dens oprindelige formål. Det mest almindelige eksempel er tilføjelsesoperatøren '+', hvor den kan bruges til almindelig tilføjelse og også til sammenføjning af to forskellige strenge.
Eksempel:
# add two numbers
print(1 + 2)
# concatenate two strings
print("Hello"+"World")
Produktion:
Fordele ved Python-overbelastning
- Øger genanvendelighed af kode.
- Øger kodens klarhed.
- Kompleksiteten i koden er meget reduceret.
Konklusion
Overbelastning spiller en vigtig rolle i mange programmeringssprog på højt niveau. I tilfælde af python, selvom de ikke impliceres direkte, har de en betydelig rolle i at undgå gentagen brug af kode.
Anbefalede artikler
Dette er en guide til Python-overbelastning. Her diskuterer vi de brugerdefinerede og foruddefinerede funktioner sammen med dens operatør og fordele. Du kan også se på de følgende artikler for at lære mere-
- Python-variabler (Top 4 typer)
- Overbelastning versus tilsidesættelse med eksempler
- Python-filoperationer
- Python Editors (Top 6 redaktører)
- Eksempler på Python-indbyggede funktioner