Python Refactoringo Technikų: Išsamus Vadovas Kodas Kokybei Gerinti

Nuolat besivystančiame programinės įrangos kūrimo pasaulyje švaraus, efektyvaus ir suprantamo kodo palaikymas yra svarbiausias. Python, žinomas dėl savo skaitomumo, vis tiek gali nukentėti nuo "blogų kvapų" kode ir techninės skolos, jei nėra tinkamai valdomas. Refactoringas yra esamo kompiuterio kodo pertvarkymo procesas – keičiant jo struktūrą – nekeičiant jo išorinio elgesio. Iš esmės tai yra kodo tvarkymas jo nesugadinant. Šiame vadove nagrinėjamos įvairios Python refactoringo technikos, pateikiami praktiniai pavyzdžiai ir geriausios praktikos, siekiant pagerinti jūsų kodo kokybę.

Kodėl Refaktoringuoti Python Kodą?

Refactoringas suteikia daugybę privalumų, įskaitant:

• Pagerintas Skaitomumas: Leidžia lengviau suprasti ir palaikyti kodą.
• Sumažintas Sudėtingumas: Supaprastina sudėtingą logiką, mažinant klaidų tikimybę.
• Patobulintas Palaikomumas: Palengvina kodo modifikavimą ir išplėtimą.
• Padidintas Našumas: Gali optimizuoti kodą geresniam vykdymo greičiui.
• Mažesnė Techninė Skola: Apsaugo nuo sunkiai palaikomo ar išplečiamo kodo kaupimosi.
• Geresnis Dizainas: Veda prie tvirtesnės ir lankstesnės kodo architektūros.

Ignoruojant refactoringą, gali atsirasti kodas, kurį sunku suprasti, modifikuoti ir testuoti. Tai gali žymiai padidinti kūrimo laiką ir klaidų įvedimo riziką.

Kada Refaktoringuoti?

Žinoti, kada refaktoringuoti, yra labai svarbu. Štai keletas dažnų scenarijų:

• Prieš Pridedant Naujas Funkcijas: Esamo kodo refactoringas gali palengvinti naujos funkcionalumo integravimą.
• Po Klaidos Ištaisymo: Refaktoringas aplink esantį kodą gali užkirsti kelią panašių klaidų pasikartojimui.
• Kodų Apžvalgų Metu: Nustatykite sritis, kurias galima pagerinti, ir jas refaktoringuokite.
• Kai Susiduriate su "Blogais Kvapais" Kode: Blogi kvapai kode yra galimų problemų jūsų kode rodikliai.
• Reguliariai Planuojamas Refactoringas: Įtraukite refactoringą į savo kūrimo procesą kaip reguliarią veiklą.

Blogų Kvapų Kode Nustatymas

Blogi kvapai kode yra paviršiniai rodikliai, kurie dažniausiai atitinka gilesnę sistemos problemą. Jie ne visada rodo problemą, bet dažnai reikalauja papildomo tyrimo.

Dažni Python Blogi Kvapų Kode Indikatoriai:

• Dubliuotas Kodas: Identinis arba labai panašus kodas, pasirodantis keliose vietose.
• Ilga Metodo/Funkcijos: Metodai ar funkcijos, kurios yra per ilgos ir sudėtingos.
• Didelė Klasė: Klasės, turinčios per daug atsakomybių.
• Ilgas Parametrų Sąrašas: Metodai ar funkcijos su per daug parametrų.
• Duomenų Sankaupos: Duomenų grupės, kurios dažnai pasirodo kartu.
• Primitinės Obsesijos: Naudojamos primityvios duomenų tipai vietoj objektų kūrimo.
• Switch Sąrašai: Ilgos if/elif/else sąrašų grandinės arba switch sąrašai.
• Šautuvo Operacija: Atlikus vieną pakeitimą reikia atlikti daugybę mažų pakeitimų skirtingose klasėse.
• Besiskiriantis Keitimasis: Klasė dažnai keičiama skirtingais būdais dėl skirtingų priežasčių.
• Funkcijos Pavydas: Metodas labiau naudoja kito objekto duomenis nei savo.
• Pranešimų Grandinės: Klientas prašo vieno objekto, kad jis paprašytų kito objekto, kad jis paprašytų dar vieno objekto...

Python Refactoringo Technikų: Praktinis Vadovas

Šiame skyriuje aprašomos kelios dažnos Python refactoringo technikos su praktiniais pavyzdžiais.

1. Metodo/Funkcijos Išėmimas

Ši technika apima kodo bloko perkėlimą į metodą ar funkciją į naują, atskirą metodą ar funkciją. Tai sumažina originalaus metodo sudėtingumą ir leidžia pakartotinai naudoti išimtą kodą.

Pavyzdys:

            
def print_invoice(customer, details):
    print("***********************")
    print(f"Customer: {customer}")
    print("***********************")

    total_amount = 0
    for order in details["orders"]:
        total_amount += order["amount"]

    print(f"Amount is : {total_amount}")

    if total_amount > 1000:
        print("You earned a discount!")

            

              
                Copy
              
            
          

Refaktoringas:

            
def print_header(customer):
    print("***********************")
    print(f"Customer: {customer}")
    print("***********************")


def calculate_total(details):
    total_amount = 0
    for order in details["orders"]:
        total_amount += order["amount"]
    return total_amount


def print_invoice(customer, details):
    print_header(customer)
    total_amount = calculate_total(details)
    print(f"Amount is : {total_amount}")

    if total_amount > 1000:
        print("You earned a discount!")

            

              
                Copy
              
            
          

2. Klasės Išėmimas

Kai klasė turi per daug atsakomybių, išimkite dalį jų į naują klasę. Tai skatina Vienos Atsakomybės Principą.

Pavyzdys:

            
class Person:
    def __init__(self, name, phone_number, office_area_code, office_number):
        self.name = name
        self.phone_number = phone_number
        self.office_area_code = office_area_code
        self.office_number = office_number

    def get_name(self):
        return self.name

    def get_phone_number(self):
        return f"({self.office_area_code}) {self.office_number}"

            

              
                Copy
              
            
          

Refaktoringas:

            
class PhoneNumber:
    def __init__(self, area_code, number):
        self.area_code = area_code
        self.number = number

    def get_phone_number(self):
        return f"({self.area_code}) {self.number}"


class Person:
    def __init__(self, name, phone_number):
        self.name = name
        self.phone_number = phone_number

    def get_name(self):
        return self.name


            

              
                Copy
              
            
          

3. Metodo/Funkcijos Įterpimas

Tai yra priešingybė Metodo Išėmimui. Jei metodo kūnas yra toks pat aiškus kaip ir jo pavadinimas, galite įterpti metodą, pakeisdami metodo iškvietimus metodo turiniu.

Pavyzdys:

            
def get_rating(driver):
    return more_than_five_late_deliveries(driver) ? 2 : 1


def more_than_five_late_deliveries(driver):
    return driver.number_of_late_deliveries > 5

            

              
                Copy
              
            
          

Refaktoringas:

            
def get_rating(driver):
    return driver.number_of_late_deliveries > 5 ? 2 : 1

            

              
                Copy
              
            
          

4. Laikinąjį Keisti į Užklausą

Užuot naudoję laikinąjį kintamąjį, kuriame laikomas išraiškos rezultatas, išimkite išraišką į metodą. Tai leidžia išvengti kodo dubliavimo ir skatina geresnį skaitomumą.

Pavyzdys:

            
def get_price(order):
    base_price = order.quantity * order.item_price
    discount_factor = 0.98 if base_price > 1000 else 0.95
    return base_price * discount_factor

            

              
                Copy
              
            
          

Refaktoringas:

            
def get_price(order):
    return base_price(order) * discount_factor(order)


def base_price(order):
    return order.quantity * order.item_price


def discount_factor(order):
    return 0.98 if base_price(order) > 1000 else 0.95

            

              
                Copy
              
            
          

5. Įvesti Parametrų Objektą

Jei turite ilgą parametrų sąrašą, kurie dažnai pasirodo kartu, apsvarstykite parametrų objekto sukūrimą, kad juos įpakuotumėte. Tai sutrumpina parametrų sąrašą ir pagerina kodo organizavimą.

Pavyzdys:

            
def calculate_total(width, height, depth, weight, shipping_method):
    # Calculation logic
    pass

            

              
                Copy
              
            
          

Refaktoringas:

            
class ShippingDetails:
    def __init__(self, width, height, depth, weight, shipping_method):
        self.width = width
        self.height = height
        self.depth = depth
        self.weight = weight
        self.shipping_method = shipping_method


def calculate_total(shipping_details):
    # Calculation logic using shipping_details attributes
    pass

            

              
                Copy
              
            
          

6. Kondicionierių Pakeisti Polimorfizmu

Kai turite sudėtingą kondicionierių, kuris pasirenka elgesį pagal objekto tipą, apsvarstykite polimorfizmo naudojimą, kad perkeltumėte elgesį į pakopas. Tai skatina geresnį kodo organizavimą ir palengvina naujų tipų pridėjimą.

Pavyzdys:

            
def calculate_bonus(employee):
    if employee.employee_type == "SALES":
        return employee.sales * 0.1
    elif employee.employee_type == "ENGINEER":
        return employee.projects_completed * 100
    elif employee.employee_type == "MANAGER":
        return 1000
    else:
        return 0

            

              
                Copy
              
            
          

Refaktoringas:

            
class Employee:
    def calculate_bonus(self):
        return 0


class SalesEmployee(Employee):
    def __init__(self, sales):
        self.sales = sales

    def calculate_bonus(self):
        return self.sales * 0.1


class EngineerEmployee(Employee):
    def __init__(self, projects_completed):
        self.projects_completed = projects_completed

    def calculate_bonus(self):
        return self.projects_completed * 100


class ManagerEmployee(Employee):
    def calculate_bonus(self):
        return 1000

            

              
                Copy
              
            
          

7. Kondicionieriaus Sudaužymas

Panašiai kaip Metodo Išėmimas, tai apima sudėtingo kondicionieriaus padalijimą į mažesnius, lengviau valdomus metodus. Tai pagerina skaitomumą ir palengvina kondicionieriaus logikos supratimą.

Pavyzdys:

            
if (platform.upper().index("MAC") > -1) and (browser.upper().index("IE") > -1) and was_initialized() and resize > MAX_RESIZE:
    # Do something
    pass

            

              
                Copy
              
            
          

Refaktoringas:

            
def is_mac_os():
    return platform.upper().index("MAC") > -1


def is_ie_browser():
    return browser.upper().index("IE") > -1


if is_mac_os() and is_ie_browser() and was_initialized() and resize > MAX_RESIZE:
    # Do something
    pass

            

              
                Copy
              
            
          

8. Magiško Numerio Pakeitimas Simboliniu Konstantu

Pakeiskite literais skaitines reikšmes pavadintomis konstantomis. Tai pagerina skaitomumą ir palengvina reikšmių keitimą vėliau. Tai taikoma ir kitoms literais reikšmėms, pvz., eilutėms. Apsvarstykite valiutų kodus (pvz., 'USD', 'EUR', 'JPY') arba būsenos kodus (pvz., 'ACTIVE', 'INACTIVE', 'PENDING') iš globalios perspektyvos.

Pavyzdys:

            
def calculate_area(radius):
    return 3.14159 * radius * radius

            

              
                Copy
              
            
          

Refaktoringas:

            
PI = 3.14159


def calculate_area(radius):
    return PI * radius * radius

            

              
                Copy
              
            
          

9. Tarpininko Pašalinimas

Jei klasė tiesiog perduoda iškvietimus kitai klasei, apsvarstykite tarpininko pašalinimą ir leiskite klientui tiesiogiai pasiekti tikslinę klasę.

Pavyzdys:

            
class Person:
    def __init__(self, department):
        self.department = department

    def get_manager(self):
        return self.department.get_manager()


class Department:
    def __init__(self, manager):
        self.manager = manager

    def get_manager(self):
        return self.manager

            

              
                Copy
              
            
          

Refaktoringas:

            
class Person:
    def __init__(self, manager):
        self.manager = manager

    def get_manager(self):
        return self.manager

            

              
                Copy
              
            
          

10. Išvados Įvedimas

Naudokite išvadas, kad dokumentuotumėte prielaidas apie programos būseną. Tai gali padėti anksti aptikti klaidas ir padaryti kodą tvirtesnį.

Pavyzdys:

            
def calculate_discount(price, discount_percentage):
    if discount_percentage < 0 or discount_percentage > 100:
        raise ValueError("Discount percentage must be between 0 and 100")
    return price * (1 - discount_percentage / 100)

            

              
                Copy
              
            
          

Refaktoringas:

            
def calculate_discount(price, discount_percentage):
    assert 0 <= discount_percentage <= 100, "Discount percentage must be between 0 and 100"
    return price * (1 - discount_percentage / 100)

            

              
                Copy
              
            
          

Įrankiai Python Refactoringui

Keletas įrankių gali padėti atliekant Python refactoringą:

• Rope: Refactoringo biblioteka Pythonui.
• PyCharm: Populiari Python IDE su integruota refactoringo palaikymu.
• VS Code su Python Priedu: Universali redagavimo priemonė su refactoringo galimybėmis per priedus.
• Sourcery: Automatinio refactoringo įrankis.
• Bowler: Facebook refactoringo įrankis didelio masto kodo modifikavimams.

Geriausios Praktikos Python Refactoringui

• Rašykite Vieneto Testus: Prieš refactoringą įsitikinkite, kad jūsų kodas yra gerai ištestuotas.
• Refaktoringuokite Mažais Žingsniais: Atlikite mažus, laipsniškus pakeitimus, kad sumažintumėte klaidų įvedimo riziką.
• Testuokite Po Kiekvieno Refactoringo Žingsnio: Patikrinkite, ar jūsų pakeitimai nieko nesugadino.
• Naudokite Versijų Kontrolę: Dažnai fiksuokite savo pakeitimus, kad prireikus galėtumėte lengvai grįžti.
• Bendradarbiaukite su Komanda: Informuokite savo komandą apie savo refactoringo planus.
• Sutelkti Dėmesį į Skaitomumą: Prioritetizuokite savo kodo suprantamumą.
• Ne Refaktoringuokite Vien Tam, Kad Tai Darytumėte: Refaktoringuokite, kai tai išsprendžia konkrečią problemą.
• Automatinis Refactoringas, Kai Galima: Naudokite įrankius pasikartojantiems refactoringo uždaviniams atlikti.

Globalios Refactoringo Apsvarstymo Nuostatos

Dirbant su tarptautiniais projektais ar pasauline auditorija, refactoringo metu atsižvelkite į šiuos veiksnius:

• Lokalizacija (L10n) ir Internacinalizacija (I18n): Įsitikinkite, kad jūsų kodas tinkamai palaiko skirtingas kalbas, valiutas ir datos formatus. Refaktoringuokite, kad izoliuotumėte lokalės specifinę logiką.
• Simbolių Kodavimas: Naudokite UTF-8 kodavimą, kad palaikytumėte platų simbolių spektrą. Refaktoringuokite kodą, kuris daro prielaidas apie specifinį kodavimą.
• Kultūrinis Jautrumas: Būkite atidūs kultūrinėms normoms ir venkite naudoti įžeidžiančią kalbą ar vaizdus. Refactoringo metu peržiūrėkite eilutes ir vartotojo sąsajos elementus.
• Laiko Juostos: Tinkamai tvarkykite laiko juostų konversijas. Refaktoringuokite kodą, kuris daro prielaidas apie vartotojo laiko juostą. Naudokite tokias bibliotekas kaip `pytz`.
• Valiutos Tvarkymas: Naudokite tinkamus duomenų tipus ir bibliotekas piniginėms vertėms tvarkyti. Refaktoringuokite kodą, kuris atlieka rankines valiutų konversijas. Tokios bibliotekos kaip `babel` yra naudingos.

Pavyzdys: Vietinių Datos Formato Nustatymas

            
import datetime

def format_date(date):
    return date.strftime("%m/%d/%Y")  # US date format

            

              
                Copy
              
            
          

Refaktoringas:

            
import datetime
import locale


def format_date(date, locale_code):
    locale.setlocale(locale.LC_TIME, locale_code)
    return date.strftime("%x")  # Locale-specific date format

# Example usage:
# format_date(datetime.date(2024, 1, 1), 'en_US.UTF-8') # Output: '01/01/2024'
# format_date(datetime.date(2024, 1, 1), 'de_DE.UTF-8') # Output: '01.01.2024'

            

              
                Copy
              
            
          

Išvada

Refactoringas yra esminė aukštos kokybės Python kodo palaikymo praktika. Nustatydami ir spręsdami blogus kvapus kode, taikydami tinkamas refactoringo technikas ir laikydamiesi geriausių praktikų, galite žymiai pagerinti savo kodo skaitomumą, palaikomumą ir našumą. Atminkite, kad refactoringo procese prioritetą teikite testavimui ir bendravimui. Refactoringo kaip nuolatinio proceso priėmimas leis sukurti tvirtesnį ir tvaresnį programinės įrangos kūrimo darbo eigą, ypač kuriant pasaulinei ir įvairiai auditorijai.