Bevezetés a Python túlterhelésbe
A túlterhelés az a folyamat, amelynek során egynél több entitás (metódusok, operátorok stb.) Ugyanazzal a névvel rendelkezik, de ezek tulajdonságaik szerint különböznek. Az attribútumok közötti különbség oka lehet az attribútumok számának különbsége vagy az attribútumok típusának különbsége. Más szavakkal, az entitás (módszerek, operátorok, stb.) Szempontjából megfogalmazható vagy magyarázható, mint az entitás képessége arra, hogy eltérően viselkedjen a neki előírt paraméterek szerint. A pythonban, mint a legtöbb más magas szintű programozási nyelvben, a python túlterhelését kétféle módon vagy példányban lehet elérni, ezeket az alábbiakban felsoroljuk,
- Funkciók vagy módszerek túlterhelése (Function Overloading).
- Operátorok túlterhelése (Operátorok túlterhelése).
Funkció túlterhelés Pythonban
A módszer túlterhelése nem alkalmazott koncepció a pythonban, de több technikával megvalósítható. Mindenekelőtt a módszer túlterhelésének fogalmát két különböző fogalomra lehet besorolni,
- A felhasználó által definiált funkciók túlterhelése.
- Az alapértelmezett funkciók túlterhelése.
1. A felhasználó által definiált funkciók túlterhelése
A felhasználó által definiált függvénytúlterhelés python-ban érhető el úgy, hogy egy paramétert vagy argumentumot nullára állít be. Tehát, ha egy argumentum nincsen beállítva, akkor a függvény egy módon reagál, ha egy értékre nem adunk át egy argumentumot, és más módon, ha egy érték nem kerül átadásra ugyanazon argumentum számára.
Példa:
#!/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)
Kimenet:
2. Az alapértelmezett vagy előre definiált funkciók túlterhelése
A beépített funkciók túlterhelése magában foglalja az előre definiált függvény meghatározását, amelyet várhatóan túlterhelnek a python osztályban speciális funkcióként. Tehát amikor az előre definiált függvényt a python osztályban speciális funkciónak nyilvánítják, akkor a tolmács ezt a speciális funkciót használja az előre definiált hívás deklarációjaként. Az alábbi példa pontosan magyarázza ezt a folyamatot.
Példa:
vegyük figyelembe a len () függvényt, amelyet ebben az esetben egy elem hosszának meghatározására használunk; az alábbi példa a hosszúság függvény szokásos használatát mutatja be anélkül, hogy túlterhelésre utalna, és elhelyezi a megfelelő ütést.
# 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))
Kimenet:
Használjuk a túlterhelési módszert a len () függvényhez ugyanabban a kódrészletben
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))
Kimenet:
Világosan megfigyelhetjük, hogy a szokásos beépítési hosszúságú funkció használata helyett a túlterhelt __len __ () speciális függvényt használjuk, amely a kimenetet mindkét lista összegzett hosszúságának kinyomtatására szolgál az egyedi hosszúság helyett.
Üzemeltető túlterhelése Pythonban
Ez magában foglalja az üzemeltető kibővített értelmezését, mint az eredeti célja. A leggyakoribb példa a „+” addíciós operátor, ahol szokásos összeadásra és két különféle karakterlánc összekapcsolására is használható.
Példa:
# add two numbers
print(1 + 2)
# concatenate two strings
print("Hello"+"World")
Kimenet:
A Python túlterhelésének előnyei
- Növeli a kód újrafelhasználhatóságát.
- Javítja a kód egyértelműségét.
- A kód bonyolultsága jelentősen csökken.
Következtetés
A túlterhelés létfontosságú szerepet játszik sok magas szintű programozási nyelvben. A python esetében, bár erre nincs közvetlen következtetés, jelentős szerepet játszanak a kód ismételt használatának elkerülésében.
Ajánlott cikkek
Ez egy útmutató a Python túlterheléshez. Itt tárgyaljuk a felhasználó által definiált és előre definiált funkciókat, azok üzemeltetőjét és előnyeit. A következő cikkeket is megnézheti további információkért -
- Python változók (4 legnépszerűbb típus)
- Túlterhelés vs felülbírálás példákkal
- Python fájlműveletek
- Python szerkesztők (6 legjobb szerkesztő)
- Példák a Python beépített funkcióira