Kuidas kasutada Python sta­tic­met­hod()

Staa­tilisi meetodeid saab kutsuda otse klassi nime kaudu, ilma et oleks vaja klassi instantsi luua. See Python staticmethod omadus hõlbustab klassi loogika ja instantsi andmete selget eral­da­mist.

Milleks ka­su­ta­takse Python staticmethod?

Python staticmethod on nii funkt­sioon kui ka dekorator. Seda ka­su­ta­takse klassi ins­tant­si­dest sõl­tu­ma­tult toimivate meetodite mää­ra­miseks. De­ko­ra­to­rid Pythonis on funkt­sioo­nid, mis muudavad teiste meetodite käitumist, lisades enne või pärast nende täitmist täien­da­vaid funkt­sioone, ilma algset funkt­sioo­ni­koodi muutmata. Erinevalt ins­tant­si­mee­to­di­test ei vaja staa­ti­li­sed funkt­sioo­nid imp­litsiit­set pa­ra­meet­rit, nagu näiteks self.

Pythonis staticmethod ka­su­ta­mine pakub kes­ken­du­nud lä­he­ne­mis­viisi klasside sees funkt­sioo­nide struk­tu­ree­ri­misele, mis ei vaja juur­de­pääsu instantsi andmetele. Kuna need ei ole seotud ins­tant­siga, ei saa nad muuta objekti seisundit. Klasside sees on need väär­tus­li­kud vahendid tavaliste üles­an­nete täit­miseks või globaalse funkt­sio­naal­suse pak­ku­miseks. Näiteks võivad need sisaldada uti­lii­di­prog­ramme, tei­sen­da­mis­ru­tiine ja üldisi abi­funkt­sioone, mida saab käivitada ilma instantsi andmeteta.

Mis on Python staticmethod süntaks?

Pythonis on staa­ti­liste meetodite loomiseks kaks võimalust. Saate kasutada funkt­siooni staticmethod() või de­ko­ra­to­rit @staticmethod.

staticmethod()

staticmethod() on sis­se­ehi­ta­tud Python-funkt­sioon, mis muudab klassi meetodi staa­ti­li­seks. Python staticmethod() tagastab staa­ti­lise meetodi funkt­sioo­nile, mis on edastatud ar­gu­men­dina. Süntaks on järgmine:

class Class:
    def staticmethodFunc(x,y):
        return x + y
Class.staticmethodFunc = staticmethod(Class.staticmethodFunc)
print('Sum = ', Class.staticmethodFunc(5,7)) # Output: Sum = 12

Edastades Class klassis mää­rat­le­tud staticmethodFunc() funkt­siooni ar­gu­men­dina staticmethod(), saame nüüd kutsuda ko­han­da­tud meetodit otse klassi nime kaudu.

@staticmethod

@staticmethod dekorator on lühem ja levinum meetod funkt­siooni staa­ti­li­seks mär­ki­miseks. Dekorator pai­gu­ta­takse klassi mää­rat­luses meetodi kohale. Süntaks on järgmine:

class Class:
    @staticmethod
    def staticmethodFunc(x, y):
        return x + y
print('Sum = ', Class.staticmethodFunc(5,7)) # Output: Sum = 12

@staticmethod dekorator annab tõlkijale märku, et mää­rat­le­tud funkt­siooni tuleks käsitleda staa­ti­lise meetodina.

Python staticmethod koo­di­näi­ted

Staa­tilisi meetodeid saab kasutada mit­me­su­guste üles­an­nete jaoks. Allpool on toodud mõned prak­ti­li­sed näited staa­ti­liste meetodite ka­su­ta­mise kohta.

Ühikute tei­sen­da­mine

Python staticmethod on väga kasulik ühikute tei­sen­da­miseks.

class Converter:
    @staticmethod
    def hoursToMinutes(hours):
        return hours * 60
    @staticmethod
    def minutesToHours(minutes):
        return minutes / 60
hours = 3
converted_minutes = Converter.hoursToMinutes(hours)
print(f"{hours} hours are {converted_minutes} minutes.") # Output: 3 hours are 180 minutes.
minutes = 180
converted_hours = Converter.minutesToHours(minutes)
print(f"{minutes} minutes are {converted_hours} hours.") # Output: 180 minutes are 3 hours.

Selles näites on klassil Converter kaks staa­ti­list meetodit tundide ja minutite va­he­li­seks tei­sen­da­miseks. Meetod hoursToMinutes() teisendab tunnid mi­nu­ti­teks, minutesToHours() aga minutid tundideks.

Me saame staa­tilisi meetodeid kutsuda klassi nime kaudu, ilma et peaksime looma klassi instantsi. Neile pääseb ligi Converter.hoursToMinutes() või Converter.minutesToHours() kaudu, kus Converter on klassi nimi. Me väl­jas­tame tulemuse f-stringis, mis on Pythonis kasutatav stringi formaat, mis ühendab väl­jen­deid.

Ma­te­maa­ti­liste arvutuste abi­funkt­sioo­nid

Teiseks ar­vu­tus­teks abi­funkt­sioo­nide mää­rat­le­miseks võite kasutada ka Pythoni sta­tic­met­hod()-funkt­siooni.

class Calculator:
    @staticmethod
    def square(x):
        return x * x
    @staticmethod
    def sqroot(x):
        return x ** 0.5
num = 9
square = Calculator.square(num)
print(f"The square of {num} is {square}.") # Output: The square of 9 is 81.
root = Calculator.sqroot(num)
print(f"The square root of {num} is {root}.") # Output: The square root of 9 is 3.

Koo­di­näide de­monst­ree­rib klassi Calculator staa­ti­liste mee­to­di­tega numbri ruudu ja ruutjuure ar­vu­ta­miseks. Kasutame de­ko­ra­to­rit @staticmethod, et märkida square() ja sqroot() staa­ti­lis­teks mee­to­di­teks. Ilma klassi instantsi loomata kutsume meetodeid klassi nime kaudu. Ühendame tulemused Calculator.square() ja Calculator.sqroot() f-stringis.

Sis­se­kan­nete kin­ni­ta­mine

Pythoni sta­tic­met­hodi teine ka­su­tus­ala on sisendite va­li­dee­ri­mine.

class Validator:
    @staticmethod
    def isInteger(num):
        try:
            int(num)
            return True
        except ValueError:
            return False
    @staticmethod
    def isDecimal(num):
        try:
            float(num)
            return True
        except ValueError:
            return False
input = "123"
is_integer = Validator.isInteger(input)
print(f"Is '{input}' an integer? {is_integer}") # Output: Is '123' an integer? True
input = "3.14"
is_dec = Validator.isDecimal(input)
print(f"Is '{input}' a decimal number? {is_dec}") # Output: Is '3.14' a decimal number? True

Klass Validator koosneb kahest staa­ti­li­sest meetodist: isInteger() ja isDecimal(). Need funkt­sioo­nid kont­rol­livad, kas antud sisend on täisarv või küm­nend­num­ber. Python staa­ti­line meetod isInteger() võtab sisendi ja üritab selle tei­sen­dada täis­ar­vuks (int(num)). Kui see õnnestub, ta­gas­ta­takse True. Muidu saame False, kui tabatakse erand ValueError, mis juhtub siis, kui va­li­dee­ri­mine ei ole võimalik.

Kasutame isDecimal() meetodit, et tei­sen­dada sisend küm­nend­mur­ruks (float(num)). Eduka tulemuse korral ta­gas­ta­takse True, muidu False. Seejärel kasutame isInteger() ja isDecimal() klassi staa­tilisi meetodeid Validator, et kont­rol­lida sisendeid "123" ja "3.14". Mõlema funkt­siooni tulemused on tõesed.

Stringide ma­ni­pu­lee­ri­mine

Allpool toodud näites mää­rat­leme klassi StringManipulation staa­ti­lise meetodiga reverseText(). See võtab pa­ra­meet­rina teksti ja kasutab lõi­ka­mis­sün­tak­sit [::-1], et tekst "Hello World!" ümber pöörata ja tulemus tagasi anda.

class StringManipulation:
    @staticmethod
    def reverseText(text):
        return text[::-1]
input_text = "Hello World!"
result = StringManipulation.reverseText(input_text)
print(f"Reversed text of '{input_text}': {result}") # Output: Reversed text of 'Hello World!': !dlroW olleH