8 sisäänrakennettua Python-sisustajaa tyylikkään koodin kirjoittamiseen

Julkaissut Platon

seuraajia: 0

8 sisäänrakennettua Python-sisustajaa tyylikkään koodin kirjoittamiseen
Kuvan toimittaja

Python puhtaalla ja luettavalla syntaksilla on laajalti käytetty korkean tason ohjelmointikieli. Python on suunniteltu helppokäyttöiseksi, mikä korostaa yksinkertaisuutta ja ohjelman ylläpitokustannuksia. Sen mukana tulee laaja kirjasto, joka vähentää kehittäjien tarvetta kirjoittaa koodia tyhjästä ja lisää kehittäjien tuottavuutta. Yksi Pythonin tehokas ominaisuus, joka edistää koodin eleganssia, ovat sisustajat.

Pythonissa koristelu on funktio, jonka avulla voit muokata toisen funktion käyttäytymistä muuttamatta sen ydinlogiikkaa. Se ottaa toisen funktion argumenttina ja palauttaa funktion laajennetulla toiminnallisuudella. Tällä tavalla voit lisätä koristeiden avulla ylimääräistä logiikkaa olemassa oleviin toimintoihin ja parantaa uudelleenkäytettävyyttä muutamalla koodirivillä. Tässä artikkelissa tutkimme kahdeksaa sisäänrakennettua Python-sisustajaa, joiden avulla voit kirjoittaa tyylikkäämpää ja ylläpidettävämpää koodia.

8 sisäänrakennettua Python-sisustajaa tyylikkään koodin kirjoittamiseen
Kuvan toimittaja

- @atexit.register dekoraattoria käytetään rekisteröimään toiminto, joka suoritetaan ohjelman päättyessä. Tätä toimintoa voidaan käyttää minkä tahansa tehtävän suorittamiseen, kun ohjelma on poistumassa, johtuupa se sitten normaalista suorituksesta tai odottamattomasta virheestä.

Esimerkiksi:

import atexit

# Register the exit_handler function
@atexit.register
def exit_handler():
    print("Exiting the program. Cleanup tasks can be performed here.")

# Rest of the program
def main():
    print("Inside the main function.")
    # Your program logic goes here.

if __name__ == "__main__":
    main()

lähtö:

Inside the main function.
Exiting the program. Cleanup tasks can be performed here.

Yllä olevassa toteutuksessa @atexit.register mainitaan funktion määritelmän yllä. Se määrittelee exit_handler() toimii poistumistoimintona. Pohjimmiltaan se tarkoittaa, että aina kun ohjelma saavuttaa päätepisteensä, joko normaalin suorituksen kautta tai odottamattoman virheen vuoksi, joka aiheuttaa ennenaikaisen poistumisen, exit_handler() toiminto otetaan käyttöön.

- @dataclasses.dataclass on tehokas koristelu, jota käytetään automaattisesti luomaan yleisiä erikoismenetelmiä luokille, kuten "__init__", "__repr__" ja muille. Se auttaa sinua kirjoittamaan selkeämpää ja ytimekkäämpää koodia, koska sinun ei tarvitse kirjoittaa tiivistemenetelmiä luokkasi ilmentymien alustamiseen ja vertailuun. Se voi myös auttaa estämään virheitä varmistamalla, että yleiset erikoismenetelmät toteutetaan johdonmukaisesti koko koodikannassa.

Esimerkiksi:

from dataclasses import dataclass

@dataclass
class Point:
    x: int
    y: int


point = Point(x=3, y=2)
# Printing object
print(point)

# Checking for the equality of two objects
point1 = Point(x=1, y=2)
point2 = Point(x=1, y=2)
print(point1 == point2)

lähtö:

Point(x=3, y=2)
True

- @dataclass Decorator, jota käytetään Point-luokan määritelmän yläpuolella, signaloi Pythonin käyttämään oletuskäyttäytymistä erityismenetelmien luomiseen. Tämä luo automaattisesti __init__ menetelmä, joka alustaa luokan attribuutit, kuten x ja y, objektin ilmentymisen yhteydessä. Tämän seurauksena pisteen kaltaisia ilmentymiä voidaan rakentaa ilman erityistä koodausta. Lisäksi, __repr__ -menetelmä, joka vastaa objektien merkkijonoesityksen tuottamisesta, säätyy myös automaattisesti. Tämä varmistaa, että kun objekti, kuten piste, tulostetaan, se tuottaa selkeän ja järjestetyn esityksen, kuten tulosteessa näkyy: Piste(x=3, y=2). Lisäksi tasavertailu (==) kahden esiintymän, piste1 ja piste2, välillä tuottaa tosi. Tämä on huomionarvoista, koska oletuksena Python tarkistaa tasa-arvon muistipaikan perusteella. Tietoluokkaobjektien yhteydessä tasa-arvo määräytyy kuitenkin niiden sisältämän tiedon perusteella. Tämä johtuu siitä, että @dataclass-koristelija luo __eq__ menetelmä, joka tarkistaa objektien sisältämien tietojen tasavertaisuuden saman muistipaikan tarkistamisen sijaan.

- @enum.unique enum-moduulista löytyvää dekoraattoria käytetään varmistamaan, että luettelon kaikkien jäsenten arvot ovat yksilöllisiä. Tämä auttaa estämään useiden samalla arvolla olevien luettelon jäsenten luomisen vahingossa, mikä voi johtaa sekaannukseen ja virheisiin. Jos kaksoisarvoja löytyy, a ValueError on nostettu.

Esimerkiksi:

from enum import Enum, unique

@unique
class VehicleType(Enum):
    CAR = 1
    TRUCK = 2
    MOTORCYCLE = 3
    BUS = 4

# Attempting to create an enumeration with a duplicate value will raise a ValueError
try:
    @unique
    class DuplicateVehicleType(Enum):
        CAR = 1
        TRUCK = 2
        MOTORCYCLE = 3
        # BUS and MOTORCYCLE have duplicate values
        BUS = 3
except ValueError as e:
    print(f"Error: {e}")

lähtö:

Error: duplicate values found in : BUS -> MOTORCYCLE

Yllä olevassa toteutuksessa "BUS" ja "MOOTTORIPYÖRÄ" on sama arvo "3". Tämän seurauksena @unique decorator nostaa ValueError-ilmoituksen viestillä, joka osoittaa, että päällekkäisiä arvoja on löydetty. Et voi myöskään käyttää samaa avainta useammin kuin kerran etkä voi määrittää samaa arvoa eri jäsenille. Tällä tavalla se auttaa estämään useiden luettelon jäsenten arvojen kaksoiskappaleet.

- partial decorator on tehokas työkalu, jota käytetään osittaisten toimintojen luomiseen. Osittaisten funktioiden avulla voit esiasettaa joitain alkuperäisen funktion argumentteja ja luoda uuden funktion, jossa argumentit on jo täytetty.

Esimerkiksi:

from functools import partial

# Original function
def power(base, exponent):
    return base ** exponent

# Creating a partial function with the exponent fixed to 2
square = partial(power, exponent=2)

# Using the partial function
result = square(3)
print("Output:",result)

lähtö:

Yllä olevassa toteutuksessa meillä on funktio "power", joka hyväksyy kaksi argumenttia "kanta" ja "eksponentti" ja palauttaa kantaluvun tuloksen eksponentin potenssiin. Olemme luoneet osafunktion nimeltä "neliö" käyttämällä alkuperäistä funktiota, jossa eksponentti on esiasetettu arvoon 2. Tällä tavalla voimme laajentaa alkuperäisten funktioiden toimivuutta käyttämällä partial sisustusarkkitehti.

- @singledisptach sisustajaa käytetään luomaan yleisiä toimintoja. Sen avulla voit määrittää erilaisia funktioiden toteutuksia samalla nimellä, mutta eri argumenttityypeillä. Se on erityisen hyödyllinen, kun haluat koodisi käyttäytyvän eri tavalla eri tietotyypeillä.

Esimerkiksi:

from functools import singledispatch

# Decorator
@singledispatch
def display_info(arg):
    print(f"Generic: {arg}")

# Registering specialized implementations for different types
@display_info.register(int)
def display_int(arg):
    print(f"Received an integer: {arg}")

@display_info.register(float)
def display_float(arg):
    print(f"Received a float: {arg}")

@display_info.register(str)
def display_str(arg):
    print(f"Received a string: {arg}")

@display_info.register(list)
def display_sequence(arg):
    print(f"Received a sequence: {arg}")

# Using the generic function with different types
display_info(39)             
display_info(3.19)          
display_info("Hello World!")
display_info([2, 4, 6])

lähtö:

Received an integer: 39
Received a float: 3.19
Received a string: Hello World!
Received a sequence: [2, 4, 6]

Yllä olevassa toteutuksessa kehitimme ensin yleisfunktion display_info() käyttäen @singledisptach decorator ja rekisteröi sitten sen toteutuksen erikseen int:lle, floatille, stringille ja listalle. Tulos näyttää toiminnan display_info() erillisille tietotyypeille.

- @classmethod on koristelu, jota käytetään luokkamenetelmien määrittelemiseen luokassa. Luokkamenetelmät on sidottu luokkaan eikä luokan objektiin. Ensisijainen ero staattisten ja luokkamenetelmien välillä on niiden vuorovaikutus luokan tilan kanssa. Luokkamenetelmillä on pääsy luokan tilaan ja ne voivat muokata sitä, kun taas staattiset menetelmät eivät pääse käsiksi luokan tilaan ja toimivat itsenäisesti.

Esimerkiksi:

class Student:
    total_students = 0

    def __init__(self, name, age):
        self.name = name
        self.age = age
        Student.total_students += 1

    @classmethod
    def increment_total_students(cls):
        cls.total_students += 1
        print(f"Class method called. Total students now: {cls.total_students}")

# Creating instances of the class
student1 = Student(name="Tom", age=20)
student2 = Student(name="Cruise", age=22)

# Calling the class method
Student.increment_total_students()  #Total students now: 3

# Accessing the class variable
print(f"Total students from student 1: {student1.total_students}")
print(f"Total students from student 2: {student2.total_students}")

lähtö:

Class method called. Total students now: 3
Total students from student 1: 3
Total students from student 2: 3

Yllä olevassa toteutuksessa opiskelija luokassa on opiskelijat yhteensä luokkamuuttujana. The @classmethod sisustajaa käytetään määrittelemään increment_total_students() luokan menetelmä kasvattaa opiskelijat yhteensä muuttuja. Aina kun luomme opiskelijaluokan esiintymän, opiskelijoiden kokonaismäärää kasvatetaan yhdellä. Loimme kaksi esiintymää luokasta ja käytimme sitten luokkamenetelmää muokkaamaan opiskelijat yhteensä muuttuja 3, mikä näkyy myös luokan esiintymissä.

- @staticmethod dekoraattoria käytetään staattisten menetelmien määrittämiseen luokassa. Staattiset menetelmät ovat menetelmiä, joita voidaan kutsua luomatta luokan esiintymää. Staattisia menetelmiä käytetään usein, kun niiden ei tarvitse käyttää objektikohtaisia parametreja ja ne liittyvät enemmän luokkaan kokonaisuutena.

Esimerkiksi:

class MathOperations:
    @staticmethod
    def add(x, y):
        return x + y

    @staticmethod
    def subtract(x, y):
        return x - y

# Using the static methods without creating an instance of the class
sum_result = MathOperations.add(5, 4)
difference_result = MathOperations.subtract(8, 3)

print("Sum:", sum_result)            
print("Difference:", difference_result)

lähtö:

Sum: 9
Difference: 5

Yllä olevassa toteutuksessa olemme käyttäneet @staticmethod määrittääksesi staattisen menetelmän add() luokalle “MathOperations”. Olemme lisänneet kaksi numeroa "4" ja "5", jolloin tuloksena on "9" luomatta luokan esiintymää. Vastaavasti vähennä kaksi numeroa "8" ja "3" saadaksesi "5". Tällä tavalla staattisia menetelmiä voidaan luoda suorittamaan aputoimintoja, jotka eivät vaadi ilmentymän tilaa.

- @property decoratorilla määritellään getter-menetelmät luokkaattribuutille. Getter-menetelmät ovat menetelmiä, jotka palauttavat attribuutin arvon. Näitä menetelmiä käytetään tietojen kapseloimiseen, joka määrittää, kuka voi käyttää luokan tai ilmentymän tietoja.

Esimerkiksi:

class Circle:
    def __init__(self, radius):
        self._radius = radius

    @property
    def radius(self):
        # Getter method for the radius.
        return self._radius

    @property
    def area(self):
        # Getter method for the area.
        return 3.14 * self._radius**2

# Creating an instance of the Circle class
my_circle = Circle(radius=5)

# Accessing properties using the @property decorator
print("Radius:", my_circle.radius)          
print("Area:", my_circle.area)

lähtö:

Radius: 5
Area: 78.5

Yllä olevassa toteutuksessa luokassa "Ympyrä" on attribuutti "radius". Olemme käyttäneet @property määrittääksesi getter-menetelmät säteelle ja alueelle. Se tarjoaa puhtaan ja yhtenäisen käyttöliittymän luokan käyttäjille näiden määritteiden käyttämiseen.

Tässä artikkelissa esitellään joitain monipuolisimmista ja toimivimmista sisustajista, joiden avulla voit tehdä koodistasi joustavamman ja luettavamman. Näillä sisustajilla voit laajentaa alkuperäisen toiminnon toimintoja, jotta se on organisoidumpi ja vähemmän altis virheille. Ne ovat kuin taikuutta, jotka saavat Python-ohjelmasi näyttämään siistiltä ja toimimaan sujuvasti.

Kanwal Mehreen on tavoitteellinen ohjelmistokehittäjä, joka on kiinnostunut datatieteestä ja tekoälyn sovelluksista lääketieteessä. Kanwal valittiin APAC-alueen Google Generation Scholar 2022 -tutkijaksi. Kanwal rakastaa teknisen tiedon jakamista kirjoittamalla artikkeleita trendikkäistä aiheista ja on intohimoinen naisten edustuksen parantamiseen teknologiateollisuudessa.