1. Panimula
Kapag nagsusulat ng mga programa sa Python, mahalaga ang mga “null check” upang tiyakin na walang data o upang pangasiwaan ang mga error. Sa Python, may espesyal na halaga na katumbas ng “null” sa ibang wika, ang None, na ibinibigay at ginagamit sa iba’t ibang sitwasyon.
Ipinaliwanag ng artikulong ito kung paano magsagawa ng mga “null check” at kung paano ito gamitin nang epektibo mula sa perspektibo ng Python. Isinulat ito upang madaling maintindihan ng mga baguhan at naglalayong magbigay ng nilalaman na maaaring ilapat sa totoong pag-unlad, kaya’t gamitin ito bilang sanggunian.
2. Ano ang “null” sa Python?
Ang mga wika sa pagprograma ay may espesyal na halaga na kumakatawan sa kawalan ng data o isang hindi wastong estado. Halimbawa, gumagamit ang JavaScript at Java ng “null”, at ang PHP ay gumagamit ng “NULL”, ngunit sa Python ito ay tinatawag na “None“.
Pangunahing konsepto ng None sa Python
Ang None ng Python ay katumbas ng “null” sa ibang wika at nagpapahiwatig na walang data o hindi pa partikular na itinakda. Sa Python, lahat ng data ay itinuturing na mga object, at ang None ay hindi naiiba — ito ay isang object ng espesyal na uri na NoneType.
Halimbawa, sa pamamagitan ng pag-assign ng None sa isang variable tulad ng ipinapakita sa ibaba, ipinapahiwatig mo na walang data ang naitakda.
x = None
Ginagawa nitong hayag na ang variable na x ay walang halagang itinakda. 
3. Pangunahing paggamit ng None
Sa Python, ginagamit ang None sa maraming sitwasyon upang hayagang ipahiwatig ang isang partikular na estado. Dito ay ipakikilala ang mga pangunahing gamit ng None.
Pag-assign ng None sa isang variable
Ang pag-assign ng None sa isang variable ay nagpapahiwatig na ito ay “walang halaga” o “hindi pa itinakda”. Ginagamit ito para sa data na hindi pa napagpasyahan o para sa mga variable na nais mong pansamantalang iwanang walang laman.
name = None
age = None
Mga function na nagbabalik ng None
Kapag ang return value ay hindi talaga kailangan sa isang function, o nais mong ipahiwatig ang “pagbabalik ng wala” sa ilalim ng ilang kondisyon, karaniwang nagbabalik ng None. Halimbawa, sa isang function tulad ng nasa ibaba, maaari mong ibalik ang None kapag hindi natugunan ang kondisyon.
def find_even_number(numbers):
for num in numbers:
if num % 2 == 0:
return num
return None
Ang function na ito ay naghahanap at nagbabalik ng isang even number, ngunit kung wala itong mahanap ay magbabalik ito ng None upang ipahiwatig na walang tumutugmang data.
4. Paano tukuyin ang None
Sa Python, karaniwang paraan upang suriin kung naka‑set ang None ay ang paggamit ng operator na is. Lalo na, ang operator na is ay lubos na mapagkakatiwalaan para sa pagsubok ng None at inirerekomenda ng opisyal na gabay sa istilo ng Python (PEP 8). Maaari ring gamitin ang operator na ==, ngunit dahil ito ay may ibang pag-uugali, dapat mag-ingat. Ipinapaliwanag sa seksyong ito ang bawat pamamaraan ng pagsubok.
Pagsusuri gamit ang operator na is
Ang operator na is ay ang standard na paraan sa Python upang suriin kung ang isang variable ay None. Ang is ay sumusuri sa pagkakakilanlan ng object, kaya ito ay angkop para matukoy ang None. Tingnan natin ang sumusunod na halimbawa.
x = None
if x is None:
print("x is None")
Sa code na ito, kung ang variable na x ay None, magpi‑print ito ng “x is None”. Ang paggamit ng operator na is ay nagpapalinaw at nagpapabasa ng code, kaya inirerekomenda itong gamitin para sa pagsubok ng None lalo na.
Mga pagkakaiba at babala kapag gumagamit ng operator na ==
Sa Python, maaari mo ring gamitin ang operator na == upang subukan ang None, ngunit ang == ay nilalayong ikumpara ang “value equality”. Gagana rin ito para sa pagsubok ng None, ngunit maaaring magdulot ito ng hindi inaasahang resulta, kaya mas mainam na gamitin ang is kapag sumusubok ng None.
x = None
if x == None: # Works, but not recommended
print("x is None")
Pagsusuri para sa negatibong kaso (is not)
Kung nais mong tiyakin na ang isang variable ay hindi None, gamitin ang operator na is not. Ang is not ay maginhawa para tukuyin kung ano ang gagawin kapag ang variable ay hindi None.
x = 5
if x is not None:
print("x is not None")
Sa halimbawang ito, kung ang x ay hindi None, magpi‑print ito ng “x is not None”. Ang paggamit ng operator na is not sa ganitong paraan ay nagbibigay-daan upang hayagang subukan ang mga kondisyon kung saan ang isang bagay ay hindi None.
5. Mga Pagkakaiba sa pagitan ng None at iba pang falsy na halaga
Sa Python, may ilang halaga bukod sa None na tinuturing na “falsy”. Kabilang dito ang walang laman na string na '', mga numerong halaga na 0, walang laman na listahan [], at iba pa. Gayunpaman, iba ang mga halagang ito kumpara sa None. Dito natin palalalimin ang pag-unawa sa mga pagkakaiba sa pagitan ng None at iba pang falsy na halaga.
Pangkalahatang-ideya ng None at iba pang falsy na halaga
Ang mga pangunahing halaga na tinuturing na falsy sa Python ay:
None- walang laman na string
'' - numerong
0 - walang laman na listahan
[] - walang laman na diksyunaryo
{}
Lahat ng mga ito ay nag-eevaluate bilang False, ngunit ang None, hindi tulad nila, ay kumakatawan sa kawalan ng isang halaga.
Mga Pagkakaiba sa pagitan ng None at ng walang laman na string ''
Ang walang laman na string '' ay nagpapahiwatig na ang data ay walang laman habang pinapanatili ang uri nitong str. Sa kabilang banda, ang None ay isang espesyal na object na walang uri. Tingnan natin ang sumusunod na halimbawa.
text = ''
if text is None:
print("text is None")
elif text == '':
print("text is an empty string")
Ang code na ito ay nagtatangi kung ang text ay isang walang laman na string o None at hinahawakan ang bawat kaso nang naaayon.
Mga Pagkakaiba mula sa numerong 0 at walang laman na listahan []
Ang numerong 0 at walang laman na listahan [] ay tinuturing din bilang False, ngunit ito ay nagpapahiwatig na mayroong numerong o listahang halaga na ang nilalaman ay walang laman. Ang None, na walang uri, ay nangangahulugang walang naitakdang halaga. Kumpirmahin natin ito sa sumusunod na halimbawa.
data = 0
if data is None:
print("data is None")
elif data == 0:
print("data is 0")
Ang pag-unawa sa mga pagkakaiba sa pagitan ng None at iba pang falsy na halaga ay magbibigay-daan sa mas tumpak na mga pagsusuri.
6. Praktikal na mga halimbawa ng paggamit ng None
Dito ay ipapaliwanag namin ang ilang kongkretong halimbawa kung paano epektibong gamitin ang None sa mga programang Python. Ang None ay malawakang ginagamit para sa mga default na argumento, paghawak ng data na nakuha mula sa mga database, paghawak ng error, at iba pa. Ang pag-unawa sa mga halimbawang ito ay nagpapabuti sa pagpapanatili at nababasa ng code.
Paggamit ng None bilang default na argumento ng isang function
Sa pamamagitan ng pagtatakda ng None bilang default na argumento ng isang function, nagiging posible ang flexible na disenyo ng function. Halimbawa, kung hindi ipinasa ang isang argumento sa isang function, maaari mong gamitin ang None upang matukoy ito at magtakda ng default na pag-uugali batay sa mga kondisyon.
def greet(name=None):
if name is None:
print("Hello, Guest!")
else:
print(f"Hello, {name}!")
Ang function na greet ay nagpapakita ng “Hello, Guest!” kapag ang argumentong name ay hindi ibinigay, at kapag ibinigay ay binabati gamit ang tinukoy na pangalan. Sa pamamagitan ng pag-leverage ng None sa ganitong paraan, madaling makalikha ng mga function na may flexible na pag-uugali.
Paghawak ng None kapag kumukuha ng data mula sa isang database
Kapag kumukuha ng data mula sa isang database, maaaring ibalik ang None kapag walang umiiral na data. Halimbawa, ang mga NULL na halaga ng SQL ay kadalasang itinuturing nang direkta bilang None, at nagsasagawa ka ng mga pagsusuri ng None upang matukoy kung nawawala ang data.
user_data = get_user_data(user_id) # Function to retrieve user data
if user_data is None:
print("No user data found")
else:
print("Displaying user data")
Dito, kung ang function na get_user_data ay hindi nagbabalik ng data ng user, None ang ibinabalik, at sa kasong iyon ay ipinapakita ang “No user data found”. Ang paggawa ng ganitong mga pagsusuri ng None ay nagpapasiguro na mas ligtas at mas maaasahan ang mga operasyon sa database.
Paggamit ng None sa paghawak ng error
Ginagamit din ang None bilang bahagi ng paghawak ng error. Lalo na sa mga sitwasyon na nangangailangan ng paghawak ng exception o pagsusuri ng error, ang pagtukoy kung ang isang resulta ay None ay nagpapadali sa pag-check para sa mga error.
def divide(a, b):
if b == 0:
return None
return a / b
result = divide(10, 0)
if result is None:
print("Error: Division by zero occurred")
else:
print(f"Result: {result}")
Sa halimbawang ito, sinusuri ng function na divide ang division by zero at nagbabalik ng None sakaling magkaroon ng error. Pinapayagan nito ang tumatawag na suriin ang None at magpakita ng angkop na mensahe ng error.
7. Mga pinakamahusay na kasanayan sa pagsuri ng None
Kapag nagsusuri ng None sa Python, ang paggamit ng tamang paraan ay maaaring mapabuti ang nababasa at pagiging maaasahan ng iyong code. Narito ang mga pinakamahusay na kasanayan sa pagsuri ng None.
Inirerekomendang paraan sa pagsuri ng None batay sa PEP 8
Ang PEP 8, opisyal na gabay sa estilo ng Python, ay nagrerekomenda ng paggamit ng operator na is upang suriin ang None. Ginagawa nitong malinaw ang pagkakakilanlan ng object at pinag-iiba ang None mula sa iba pang falsy na halaga.
value = None
if value is None:
print("value is None")
Ang paggamit ng is upang suriin ang None ay nagpapabuti ng nababasa at nililinaw ang layunin, na tumutulong maiwasan ang mga bug.
Mga halimbawa ng code upang mapabuti ang nababasa at pagpapanatili
Para sa nababasa at pagpapanatili, mahalagang suriin ang None gamit ang simpleng, madaling maintindihang code. Gayundin, kapag inaasahan ang None, ang pagdaragdag ng mga komento upang linawin ang layunin at intensyon ng None ay kapaki-pakinabang.
# When no value is set, None is expected
data = fetch_data()
if data is None:
print("Could not retrieve data")
Sa ganitong paraan, ang paglilinaw ng kahulugan ng None sa pamamagitan ng mga komento ay nagpapadali sa hinaharap na pagpapanatili ng code.
