Mga Pinakamahuhusay na Kasanayan sa Python

Ipinaliliwanag ng artikulong ito ang mga pinakamahuhusay na kasanayan sa Python.

Ipapaliwanag namin ang mga pinakamahusay na kasanayan sa Python gamit ang aktuwal na mga halimbawa ng code, na nagpapakita ng mga paraan kung paano magsulat ng madaling basahin at mapanatiling code.

YouTube Video

Mga Pinakamahuhusay na Kasanayan sa Python

Gawing pangunahing prayoridad ang pagiging madaling basahin

Unang-una, tingnan natin ang 'paggawang pangunahing prayoridad ang pagiging madaling basahin.'.

Ang Python ay isang wika na pinahahalagahan ang 'pagiging madaling basahin.'. Unahin ang pagsulat ng code na malinaw ang layunin sa unang tingin pa lang.

1# Bad example: unclear variable names
2a = 10
3b = 5
4c = a * b

Sa code na ito, hindi malinaw sa pangalan ng mga variable ang kanilang kahulugan kaya nagiging matagal para sa iba na maintindihan ito sa kalaunan.

1# Good example: descriptive variable names
2price = 10
3quantity = 5
4total_cost = price * quantity

Sa pagpapalinaw ng pangalan ng mga variable, ang mismong code mo na ang nagsisilbing dokumentasyon.

Magsulat ng hayag na code

Sunod, tingnan natin ang 'pagsusulat ng hayag na code.'.

Sa Python, mas pinipili ang 'hayag na layunin' kaysa sa 'palihim na kilos.'.

1# Bad example: implicit truthy check
2if data:
3    process(data)

Sa code na ito, hindi malinaw kung ano ang inaasahan mula sa data, na maaaring magdulot ng mga bug.

1# Good example: explicit condition
2if len(data) > 0:
3    process(data)

Sa paghayag ng mga kondisyon, tumutugma ang layunin ng code sa kanyang ispesipikasyon.

Panatilihing maliit ang mga function at magpokus sa isang tungkulin lang

Sunod, tingnan natin ang 'pagpapanatiling maliit at nakatuon sa isang tungkulin lamang ang mga function.'.

Kapag masyadong marami ang ginagawa ng isang function, nagiging mahirap ang pagsusuri at pagpapanatili nito.

1# Bad example: doing too many things
2def handle_user(user):
3    save_to_database(user)
4    send_email(user)
5    write_log(user)

Sa code na ito, nagiging masyadong magkadikit ang mga proseso kaya nagiging mahirap gamitin muli at baguhin.

1# Good example: single responsibility
2def save_user(user):
3    save_to_database(user)
4
5def notify_user(user):
6    send_email(user)
7
8def log_user(user):
9    write_log(user)

Sa paghahati-hati ng mga function, nagiging malinaw ang mga tungkulin nila at mas madali ring magsagawa ng pagsubok.

Gamitin ang type hints nang aktibo

Sunod, tingnan natin ang 'aktibong paggamit ng type hints.'.

Ang type hints ay nagsisilbing dokumentasyon at isang makapangyarihang paraan para maiwasan ang mga bug.

1# Bad example: Without type hints
2def add(a, b):
3    return a + b

Sa code na ito, hindi malinaw ang types ng mga argumento at return value kaya nagiging madali ang maling paggamit.

1# Good example: With type hints
2def add(a: int, b: int) -> int:
3    return a + b

Sa paggamit ng type hints, malaki ang ginhawang dulot sa IDE completion, static analysis, at pagiging madaling basahin.

Hayagang ipahiwatig ang posibilidad na magbalik ng None

Sunod, tingnan natin ang 'hayagang pagpapahiwatig ng posibilidad na magbalik ng None.'.

Ang mga function na maaaring magbalik ng None ay kadalasang hindi napapansin ng mga gumagamit nito.

1# Bad example: Ambiguous return value
2def find_user(user_id):
3    if user_id == 1:
4        return {"id": 1, "name": "Alice"}
5    return None

Sa code na ito, hindi malinaw kung mayroon bang ibabalik na value.

1# Good example: explicit return type
2from typing import Optional, Dict, Any
3
4def find_user(user_id: int) -> Optional[Dict[str, Any]]:
5    if user_id == 1:
6        return {"id": 1, "name": "Alice"}
7    return None

Sa paggamit ng Optional, maipapakita mo ang posibilidad ng pagbalik ng None bilang isang uri.

Huwag hulihin ang mga exception nang masyadong malawak

Sunod, tingnan natin ang 'huwag hulihin ang mga exception nang masyadong malawak.'.

Sa exception handling, dapat na hulihin lamang ang kinakailangan.

1# Bad example: catching all exceptions
2try:
3    result = int(value)
4except Exception:
5    result = 0

Ang code na ito ay maaaring magtago ng mga bug na dapat sana'y napansin.

1# Good example: catch specific exception
2try:
3    result = int(value)
4except ValueError:
5    result = 0

Sa pamamagitan ng paglilimita ng mga exception, hindi mo mapapalampas ang mga hindi inaasahang isyu.

Hawakang ligtas ang mga resource gamit ang with statement

Sunod, tingnan natin ang 'ligtas na paghawak ng mga resource gamit ang with statement.'.

Ang mga resource tulad ng file at lock ay dapat laging mapakawalan nang maayos.

1# Bad example: manual close
2file = open("data.txt")
3content = file.read()
4file.close()

Sa code na ito, kung may maganap na exception, maaaring hindi matawag ang close().

1# Good example: using context manager
2with open("data.txt") as file:
3    content = file.read()

Sa paggamit ng with statement, ligtas na nagaganap ang cleanup kahit pa may exception.

Gamitin nang wasto ang list comprehensions

Sunod, tingnan natin ang 'wastong paggamit ng list comprehensions.'.

Ang mga simpleng pag-transform ng datos ay maaaring maisulat nang maikli gamit ang list comprehensions.

1# Bad example: Verbose loop
2squares = []
3for i in range(10):
4    squares.append(i * i)

Sa code na ito, mahirap makita ang pangunahing proseso.

1# Good example: Clear list comprehension
2squares = [i * i for i in range(10)]

Sa wastong paggamit ng list comprehensions, gumaganda ang madaling basahin ng code.

Iwasan ang magic numbers

Sunod, tingnan natin ang 'pag-iwas sa magic numbers.'.

Ang tuwirang pagsulat ng mga numero at string ay nagpapalabo ng kanilang kahulugan.

1# Bad example: magic number
2if status == 404:
3    handle_not_found()

Sa code na ito, inaasume na alam mo ang ibig sabihin ng 404.

1# Good example: named constant
2NOT_FOUND = 404
3
4if status == NOT_FOUND:
5    handle_not_found()

Ang pagbibigay ng pangalan ay nagpapalinaw ng layunin.

Magsulat ng code na madaling mapanatili, hindi lang 'gumagana'

Sa wakas, tingnan natin ang 'pagsusulat ng code na madaling mapanatili, hindi lang yung gumagana.'.

Ang mahalaga ay kung mababasa ng sarili mo sa hinaharap o ng iba ang code mo.

1# Bad example: Hard to maintain
2def f(x):
3    return x * 1.08 + 100

Sa code na ito, hindi mo maintindihan ang ispesipikasyon mula sa code.

1# Good example: Easy to maintain
2TAX_RATE = 1.08
3BASE_FEE = 100
4
5def calculate_total(price: float) -> float:
6    return price * TAX_RATE + BASE_FEE

Sa pagbibigay ng kahulugan sa pangalan, ang code mismo ay nagiging ispesipikasyon.

Buod

Ang mga pinakamahusay na kasanayan sa Python ay nauuwi sa pagsulat ng code na madaling maintindihan, hindi lang matalino o komplikadong code. Ang pagtatayo ng maliliit na magandang kaugalian ay nagbubunga ng code na may mas kaunting bug at magagamit nang matagal.

Maaari mong sundan ang artikulo sa itaas gamit ang Visual Studio Code sa aming YouTube channel. Paki-check din ang aming YouTube channel.

YouTube Video