Python kodingizning saqlanishi, o'qilishi va ishlashini samarali qayta tuzish usullari bilan yaxshilang. Kod sifatini oshirish uchun amaliy strategiyalar va eng yaxshi tajribalarni o'rganing.
Python-ni qayta tuzish usullari: Kod sifatini yaxshilash bo'yicha to'liq qo'llanma
Dasturiy ta'minotni ishlab chiqishning doimiy o'zgaruvchan landshaftida toza, samarali va tushunarli kodni saqlash juda muhimdir. O'zining o'qilishi bilan mashhur bo'lgan Python, agar ehtiyotkorlik bilan boshqarilmasa, kodning hidlari va texnik qarzlari qurboni bo'lishi mumkin. Qayta tuzish - bu tashqi xatti-harakatlarini o'zgartirmasdan mavjud kompyuter kodini qayta qurish jarayoni - omillarni o'zgartirish. Aslida, bu sizning kodingizni buzmasdan tozalash. Ushbu qo'llanma kod sifatini oshirish uchun amaliy misollar va eng yaxshi tajribalarni taqdim etib, Python-ni qayta tuzishning turli usullarini o'rganadi.
Nima uchun Python kodini qayta tuzish kerak?
Qayta tuzish ko'plab afzalliklarni taqdim etadi, jumladan:
- O'qilishni yaxshilash: Kodni tushunish va saqlashni osonlashtiradi.
- Murakkablikni kamaytirish: Murakkab mantiqni soddalashtiradi, xatoliklar ehtimolini kamaytiradi.
- Saqlanishni yaxshilash: Kodni osonroq o'zgartirish va kengaytirishga yordam beradi.
- Ishlashni oshirish: Kodni yaxshiroq bajarish tezligi uchun optimallashtirishi mumkin.
- Texnik qarzlarni kamaytirish: Saqlash yoki kengaytirish qiyin bo'lgan kodning to'planishining oldini oladi.
- Yaxshiroq dizayn: Yanada mustahkam va moslashuvchan kod arxitekturasiga olib keladi.
Qayta tuzishga e'tibor bermaslik tushunish, o'zgartirish va sinovdan o'tkazish qiyin bo'lgan kodga olib kelishi mumkin. Bu dasturiy ta'minotni ishlab chiqish vaqtini sezilarli darajada oshirishi va xatolarni kiritish xavfini tug'dirishi mumkin.
Qachon qayta tuzish kerak?
Qachon qayta tuzishni bilish juda muhimdir. Mana ba'zi umumiy stsenariylar:
- Yangi funksiyalarni qo'shishdan oldin: Mavjud kodni qayta tuzish yangi funksiyalarni integratsiya qilishni osonlashtirishi mumkin.
- Xatoni tuzatgandan so'ng: Atrofdagi kodni qayta tuzish shunga o'xshash xatolarning takrorlanishining oldini oladi.
- Kodni ko'rib chiqish paytida: Yaxshilanishi mumkin bo'lgan joylarni aniqlang va ularni qayta tuzing.
- "Kod hidlari"ga duch kelganingizda: Kod hidlari kodingizdagi potentsial muammolarning ko'rsatkichidir.
- Muntazam rejalashtirilgan qayta tuzish: Qayta tuzishni doimiy faoliyat sifatida dasturiy ta'minotni ishlab chiqish jarayoniga kiriting.
Kod hidlarini aniqlash
Kod hidlari odatda tizimdagi chuqurroq muammoga mos keladigan sirt ko'rsatkichlaridir. Ular har doim ham muammoni ko'rsatmaydi, lekin ular ko'pincha qo'shimcha tekshiruvni talab qiladi.
Umumiy Python kodining hidlari:
- Nusxa olingan kod: Bir xil yoki juda o'xshash kod bir nechta joylarda paydo bo'ladi.
- Uzoq usul/funktsiya: Haddan tashqari uzun va murakkab usullar yoki funktsiyalar.
- Katta sinf: Juda ko'p mas'uliyatga ega bo'lgan sinflar.
- Uzoq parametrlar ro'yxati: Juda ko'p parametrlarga ega usullar yoki funktsiyalar.
- Ma'lumotlar to'plami: Tez-tez birga paydo bo'ladigan ma'lumotlar guruhlari.
- Primitiv obsesiya: Ob'ektlar yaratish o'rniga primitiv ma'lumotlar turlaridan foydalanish.
- O'tish bayonotlari: If/elif/else bayonotlarining uzun zanjirlari yoki o'tish bayonotlari.
- Miltiq operatsiyasi: Bitta o'zgarishni amalga oshirish turli sinflarga ko'plab kichik o'zgarishlar kiritishni talab qiladi.
- Divergent o'zgarish: Sinf odatda turli sabablarga ko'ra turli yo'llar bilan o'zgartiriladi.
- Xususiyat hasadi: Usul o'z ma'lumotlariga qaraganda boshqa ob'ektning ma'lumotlariga ko'proq kiradi.
- Xabar zanjirlari: Mijoz bir ob'ektdan boshqa ob'ektni so'rashni, undan esa boshqa ob'ektni so'rashni so'raydi...
Python-ni qayta tuzish usullari: Amaliy qo'llanma
Ushbu bo'limda amaliy misollar bilan Python-ni qayta tuzishning bir nechta umumiy usullari batafsil bayon etilgan.
1. Usul/funktsiyani chiqarish
Ushbu usul usul yoki funktsiya ichidagi kod blokini olish va uni yangi, alohida usul yoki funktsiyaga ko'chirishni o'z ichiga oladi. Bu asl usulning murakkabligini kamaytiradi va chiqarilgan kodni qayta ishlatish imkonini beradi.
Misol:
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!")
Qayta tuzilgan:
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!")
2. Sinfni chiqarish
Sinf juda ko'p mas'uliyatga ega bo'lganda, ularning ba'zilarini yangi sinfga chiqaring. Bu bitta mas'uliyat tamoyilini qo'llab-quvvatlaydi.
Misol:
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}"
Qayta tuzilgan:
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
3. Usul/funktsiyani ichiga joylashtirish
Bu usulni chiqarishning aksi. Agar usulning tanasi uning nomi kabi aniq bo'lsa, usulga qo'ng'iroqlarni usulning mazmuni bilan almashtirish orqali usulni ichiga joylashtirishingiz mumkin.
Misol:
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
Qayta tuzilgan:
def get_rating(driver):
return driver.number_of_late_deliveries > 5 ? 2 : 1
4. Vaqtinchalikni so'rov bilan almashtirish
Ifoda natijasini saqlash uchun vaqtinchalik o'zgaruvchidan foydalanish o'rniga, ifodani usulga chiqaring. Bu kodning takrorlanishiga yo'l qo'ymaydi va o'qilishni yaxshilaydi.
Misol:
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
Qayta tuzilgan:
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
5. Parametr ob'ektini kiritish
Agar sizda tez-tez birga paydo bo'ladigan uzun parametrlar ro'yxati bo'lsa, ularni kapsulalash uchun parametr ob'ektini yaratishni ko'rib chiqing. Bu parametrlar ro'yxatining uzunligini qisqartiradi va kodni tashkil qilishni yaxshilaydi.
Misol:
def calculate_total(width, height, depth, weight, shipping_method):
# Hisoblash mantig'i
pass
Qayta tuzilgan:
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):
# shipping_details atributlaridan foydalangan holda hisoblash mantig'i
pass
6. Shartni polimorfizm bilan almashtirish
Agar sizda ob'ekt turiga qarab xatti-harakatni tanlaydigan murakkab shartli bayonot bo'lsa, xatti-harakatni kichik sinflarga topshirish uchun polimorfizmdan foydalanishni ko'rib chiqing. Bu kodni yaxshiroq tashkil qilishga yordam beradi va yangi turlarni qo'shishni osonlashtiradi.
Misol:
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
Qayta tuzilgan:
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
7. Shartni ajratish
Usulni chiqarishga o'xshash, bu murakkab shartli bayonotni kichikroq, boshqariladigan usullarga bo'lishni o'z ichiga oladi. Bu o'qilishni yaxshilaydi va shartning mantiqini tushunishni osonlashtiradi.
Misol:
if (platform.upper().index("MAC") > -1) and (browser.upper().index("IE") > -1) and was_initialized() and resize > MAX_RESIZE:
# Nimadir qiling
pass
Qayta tuzilgan:
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:
# Nimadir qiling
pass
8. Sehrli raqamni ramziy konstanta bilan almashtirish
So'zma-so'z raqamli qiymatlarni nomlangan konstantalar bilan almashtiring. Bu o'qilishni yaxshilaydi va qiymatlarni keyinroq o'zgartirishni osonlashtiradi. Bu boshqa so'zma-so'z qiymatlarga, masalan, satrlarga ham tegishli. Global nuqtai nazardan valyuta kodlarini (masalan, 'USD', 'EUR', 'JPY') yoki holat kodlarini (masalan, 'ACTIVE', 'INACTIVE', 'PENDING') ko'rib chiqing.
Misol:
def calculate_area(radius):
return 3.14159 * radius * radius
Qayta tuzilgan:
PI = 3.14159
def calculate_area(radius):
return PI * radius * radius
9. O'rta odamni olib tashlang
Agar sinf shunchaki boshqa sinfga qo'ng'iroqlarni topshirsa, o'rta odamni olib tashlashni va mijozga to'g'ridan-to'g'ri maqsad sinfiga kirishga ruxsat berishni ko'rib chiqing.
Misol:
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
Qayta tuzilgan:
class Person:
def __init__(self, manager):
self.manager = manager
def get_manager(self):
return self.manager
10. Tasdiqni kiritish
Dastur holati haqidagi taxminlarni hujjatlashtirish uchun tasdiqlardan foydalaning. Bu xatolarni erta tutishga yordam beradi va kodni yanada mustahkam qiladi.
Misol:
def calculate_discount(price, discount_percentage):
if discount_percentage < 0 or discount_percentage > 100:
raise ValueError("Chegirma foizi 0 dan 100 gacha bo'lishi kerak")
return price * (1 - discount_percentage / 100)
Qayta tuzilgan:
def calculate_discount(price, discount_percentage):
assert 0 <= discount_percentage <= 100, "Chegirma foizi 0 dan 100 gacha bo'lishi kerak"
return price * (1 - discount_percentage / 100)
Python-ni qayta tuzish uchun vositalar
Python-ni qayta tuzishda yordam beradigan bir nechta vositalar mavjud:
- Rope: Python uchun qayta tuzish kutubxonasi.
- PyCharm: O'rnatilgan qayta tuzishni qo'llab-quvvatlaydigan mashhur Python IDE.
- Python kengaytmasi bilan VS Code: Kengaytmalar orqali qayta tuzish imkoniyatlariga ega bo'lgan ko'p qirrali muharrir.
- Sourcery: Avtomatlashtirilgan qayta tuzish vositasi.
- Bowler: Facebook-dan katta hajmdagi kod o'zgarishlari uchun qayta tuzish vositasi.
Python-ni qayta tuzish bo'yicha eng yaxshi tajribalar
- Birlik testlarini yozing: Qayta tuzishdan oldin kodingiz yaxshi sinovdan o'tkazilganligiga ishonch hosil qiling.
- Kichik qadamlarda qayta tuzish: Xatolarni kiritish xavfini minimallashtirish uchun kichik, bosqichma-bosqich o'zgarishlar qiling.
- Har bir qayta tuzish qadamidan keyin sinovdan o'tkazing: O'zgarishlaringiz hech narsani buzmaganligini tekshiring.
- Versiya nazoratidan foydalaning: Zarurat tug'ilganda osongina qaytarish uchun o'zgarishlaringizni tez-tez saqlang.
- Jamoangiz bilan muloqot qiling: Jamoangizga qayta tuzish rejalaringiz haqida xabar bering.
- O'qilishga e'tibor qarating: Kodingizni tushunishni osonlashtirishni ustuvor qo'ying.
- Faqat o'zgartirish uchun qayta tuzmang: Muammoli vaziyatlarda qayta tuzing.
- Mumkin bo'lganda qayta tuzishni avtomatlashtiring: Takroriy qayta tuzish vazifalarini avtomatlashtirish uchun vositalardan foydalaning.
Qayta tuzish uchun global mulohazalar
Xalqaro loyihalarda yoki global auditoriya uchun ishlayotganda qayta tuzish vaqtida ushbu omillarni hisobga oling:- Mahalliylashtirish (L10n) va Internatsionalizatsiya (I18n): Kodingiz turli tillarni, valyutalarni va sana formatlarini to'g'ri qo'llab-quvvatlashiga ishonch hosil qiling. Mahalliyga xos mantiqni ajratish uchun qayta tuzing.
- Belgilar kodlash: Belgilarning keng doirasini qo'llab-quvvatlash uchun UTF-8 kodlashdan foydalaning. Muayyan kodlashni taxmin qiladigan kodni qayta tuzing.
- Madaniy sezgirlik: Madaniy normalarga e'tiborli bo'ling va haqorat qilishi mumkin bo'lgan til yoki tasvirlardan foydalanishdan saqlaning. Qayta tuzish vaqtida satr yozuvlarini va foydalanuvchi interfeysi elementlarini ko'rib chiqing.
- Vaqt zonasi: Vaqt zonasi konvertatsiyasini to'g'ri boshqaring. Foydalanuvchining vaqt zonasi haqida taxminlar qiladigan kodni qayta tuzing. `pytz` kabi kutubxonalardan foydalaning.
- Valyutani boshqarish: Pul qiymatlarini boshqarish uchun tegishli ma'lumotlar turlari va kutubxonalardan foydalaning. Valyuta konvertatsiyasini qo'lda bajaradigan kodni qayta tuzing. `babel` kabi kutubxonalar foydali.
Misol: Sana formatlarini mahalliylashtirish
import datetime
def format_date(date):
return date.strftime("%m/%d/%Y") # AQSh sana formati
Qayta tuzilgan:
import datetime
import locale
def format_date(date, locale_code):
locale.setlocale(locale.LC_TIME, locale_code)
return date.strftime("%x") # Mahalliyga xos sana formati
# Misol foydalanish:
# format_date(datetime.date(2024, 1, 1), 'en_US.UTF-8') # Natija: '01/01/2024'
# format_date(datetime.date(2024, 1, 1), 'de_DE.UTF-8') # Natija: '01.01.2024'
Xulosa
Qayta tuzish yuqori sifatli Python kodini saqlash uchun muhim amaliyotdir. Kod hidlarini aniqlash va ularni bartaraf etish, tegishli qayta tuzish usullarini qo'llash va eng yaxshi tajribalarga rioya qilish orqali siz kodingizning o'qilishini, saqlanishini va ishlashini sezilarli darajada yaxshilashingiz mumkin. Qayta tuzish jarayonida sinovdan o'tkazish va muloqotga ustunlik bering. Qayta tuzishni doimiy jarayon sifatida qabul qilish yanada mustahkam va barqaror dasturiy ta'minotni ishlab chiqish ish jarayoniga olib keladi, ayniqsa global va xilma-xil auditoriya uchun ishlab chiqilayotganda.