Kā lietot Python sta­ticmethod()

Statiskās metodes var izsaukt tieši, iz­man­to­jot klases nosaukumu, bez ne­pie­cie­ša­mī­bas in­stan­ciēt klasi. Šī Python staticmethod īpašība atvieglo klases loģikas skaidru no­šķir­ša­nu no in­stan­cē­ša­nas datiem.

Kādam nolūkam tiek izmantots Python staticmethod?

Python staticmethod ir gan funkcija, gan de­ko­ra­tors. To izmanto, lai apzīmētu metodes, kas darbojas ne­at­ka­rī­gi no klases instancēm. De­ko­ra­to­ri Python ir funkcijas, kas maina citu metožu darbību, pie­vie­no­jot papildu fun­kcio­na­li­tā­ti pirms vai pēc to izpildes, nemainot sākotnējo funkcijas kodu. Atšķirībā no instancēm metodēm, sta­tis­ka­jām funkcijām nav ne­pie­cie­šams implicīts parametrs, piemēram, self.

staticmethod iz­man­to­ša­na Python piedāvā kon­cen­trē­tu pieeju funkciju struk­tu­rē­ša­nai klasēs, kurām nav ne­pie­cie­ša­ma piekļuve instancēm. Tā kā tās nav saistītas ar instanci, tās nevar mainīt objekta stāvokli. Klasēs tās kalpo kā vērtīgi rīki kopīgu uzdevumu izpildei vai globālu funkciju pie­dā­vā­ša­nai. Piemēram, tās var ietvert uti­lītprog­ram­mas, kon­ver­tē­ša­nas rutīnas un vis­pā­rī­gas pa­līgfun­kci­jas, kuras var izsaukt bez instancēm.

Kāda ir Python staticmethod sintakse?

Python valodā ir divi veidi, kā izveidot statiskas metodes. Jūs varat izmantot staticmethod() funkciju vai @staticmethod de­ko­ra­to­ru.

staticmethod()

staticmethod() ir iebūvēta Python funkcija, kas padara klases metodi statisku. Python staticmethod() at­grie­ša­nas vērtība ir statiska metode funkcijai, kas tiek nodota kā arguments. Sintakse ir šāda:

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

Pārsūtot staticmethodFunc() funkciju, kas definēta Class klasē kā arguments staticmethod(), tagad varam izsaukt pielāgoto metodi tieši caur klases nosaukumu.

@staticmethod

De­ko­ra­tors @staticmethod ir īsāka un iz­pla­tī­tā­ka metode, lai atzīmētu funkciju kā statisku. De­ko­ra­tors tiek novietots virs metodes klases de­fi­nī­ci­jā. Sintakse ir šāda:

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

@staticmethod de­ko­ra­tors norāda in­ter­pre­ta­to­ram, ka definētā funkcija jāuzskata par statisku metodi.

Python staticmethod koda piemēri

Statiskās metodes var izmantot dažādiem uz­de­vu­miem. Turpmāk ir sniegti daži praktiski piemēri, kā izmantot statiskās metodes.

Vienību kon­ver­tē­ša­na

Python staticmethod ir ļoti noderīgs vienību kon­ver­tē­ša­nai.

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.

Šajā piemērā klasē Converter ir divas statiskas metodes, kas veic kon­ver­tē­ša­nu starp stundām un minūtēm. Metode hoursToMinutes() konvertē stundas minūtēs, bet minutesToHours() konvertē minūtes stundās.

Mēs varam izsaukt statiskās metodes, iz­man­to­jot klases nosaukumu, bez ne­pie­cie­ša­mī­bas izveidot klases instanci. Tām piekļūst, iz­man­to­jot Converter.hoursToMinutes() vai Converter.minutesToHours(), kur Converter ir klases nosaukums. Mēs izvadām rezultātu f-string, Python string formātā, kas saista iz­teik­smes.

Pa­līgfun­kci­jas ma­te­mā­tis­ka­jiem ap­rē­ķi­niem

Jūs varat arī izmantot Python statisko metodi sta­ticmethod(), lai definētu pa­līgfun­kci­jas se­kun­dā­riem ap­rē­ķi­niem.

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.

Koda piemērā parādīta Calculator klase ar statiskām metodēm skaitļa kvadrāta un kvad­rāt­sak­nes ap­rē­ķi­nā­ša­nai. Mēs iz­man­to­jam @staticmethod de­ko­ra­to­ru, lai atzīmētu square() un sqroot() kā statiskas metodes. Ne­iz­vei­do­jot klases instanci, mēs izsaucam metodes, iz­man­to­jot klases nosaukumu. Mēs sa­vie­no­jam Calculator.square() un Calculator.sqroot() re­zul­tā­tus f-stringā.

Ierakstu ap­stip­ri­nā­ša­na

Vēl viens Python statiskās metodes pie­lie­to­jums ir ievades va­li­dē­ša­na.

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

Validator klasē ir divas statiskas metodes: isInteger() un isDecimal(). Šīs funkcijas pārbauda, vai dotā ievade ir vesels skaitlis vai de­ci­māl­skait­lis. Python statiskā metode isInteger() pieņem ievadi un mēģina to pārvērst veselos skaitļos (int(num)). Ja tas izdodas, tiek atgriezts True. Pretējā gadījumā mēs saņemam False, ja tiek noķerta izņēmuma situācija ValueError, kas notiek, ja va­li­dā­ci­ja nav iespējama.

Mēs iz­man­to­jam isDecimal() metodi, lai pārvērstu ievadi de­ci­māl­skait­lī (float(num)). Ja tas izdodas, tiek atgriezts True, citādi False. Tad mēs iz­man­to­jam isInteger() un isDecimal() statiskās metodes no Validator klases, lai pār­bau­dī­tu ievades "123" un "3.14". Rezultāti ir patiesi abām funkcijām.

Stīgu ma­ni­pu­lā­ci­ja

Zemāk redzamajā piemērā mēs definējam klasi StringManipulation ar statisko metodi reverseText(). Tā kā parametru izmanto tekstu un izmanto sa­da­lī­ša­nas sintaksi [::-1], lai apgrieztu tekstu "Hello World!" un atgrieztu rezultātu.

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