Para sa Loop sa Python
Ang isang para sa loop statement sa Python ay sunud-sunod na umuulit sa mga kasapi ng anumang bagay, listahan, string atbp Kung ihinahambing sa iba pang mga wika ng programa, ang syntax nito ay mas malinis at hindi nangangailangan ng manu-manong pagtukoy sa mga hakbang sa pag-ulit at pagsisimula ng pag-ulit. Bagaman may mga paraan upang gawin ang pag-uugali nito kapareho ng iba pang mga wika sa pagprograma (hindi masasaklaw sa artikulong ito). Maaari mo ring gamitin ang ilang kontrol sa para sa mga loop sa pamamagitan ng paggamit ng mga pahayag tulad ng magpatuloy, masira, pumasa atbp Sa ibaba ay isang simpleng halimbawa ng para sa loop sa Python:
para saxsa saklaw(10):
mag-print(x)
Ang para sa loop sa itaas ay mai-print ang sampung mga numero na nagsisimula sa 0 at nagtatapos sa 9.
Ilista ang Mga Pag-unawa
Ang pag-unawa sa listahan ay walang iba kundi isang maikli / maigsi na paraan upang magsulat ng multi-line para sa mga loop sa isang isang liner na pahayag. Ang halimbawa ng pagkaunawa sa listahan sa ibaba ay lilikha ng isang bagong listahan bilang [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] sa pamamagitan ng pagsasama ng lahat ng mga halagang x dito.
numero= [xpara saxsa saklaw(10)]
mag-print (numero)
Tandaan na ang pag-unawa sa listahan ay laging lumilikha ng isang bagong listahan at hindi binabago ang mga orihinal na iterable na ginamit sa expression. Ang isang karaniwang expression ng pag-unawa sa listahan ay dapat magkaroon ng para sa sugnay at maaaring sundin ng kung at iba pang mga kondisyong pahayag. Nang hindi gumagamit ng isang pagkaunawa sa listahan, ang halimbawa sa itaas ay isusulat sa sumusunod na pamamaraan:
numero= []
para saxsa saklaw(10):
numero.idugtong(x)
mag-print (numero)
Pagganap at Kakayahang mabasa
Ang mga pagkaunawa sa listahan ay mas mabilis kaysa sa mga loop. Gayunpaman, maliban kung umuulit ka sa daan-daang libu-libong mga item, hindi mo mapapansin ang mga pangunahing pagpapahusay sa pagganap. Habang ang pag-unawa sa listahan ay nagbibigay ng isang maigsi na paraan upang magsulat para sa mga loop, ang mga kumplikadong ekspresyon ay maaaring humantong sa mahinang kakayahang mabasa ng code at tumaas ang pagkasensitibo. Mahalagang panatilihing nababasa ang code, maliban kung ang pagkamit ng maximum na pagganap ay isang ganap na pangangailangan para sa iyong programa.
Halimbawa: Paggamit ng Syntax ng Mga Pag-unawa sa Listahan sa Mga Diksyonaryo at Sets
Ang isang diksyunaryo ng sawa ay isang koleksyon ng mga elemento na tinukoy sa mga pares na key-halaga habang ang isang hanay ay isang koleksyon ng mga natatanging halaga kung saan hindi pinapayagan ang mga duplicate. Ang mga pag-unawa sa listahan ay maaaring magamit sa mga dictionaryo at set ng Python din. Ang syntax ay naiiba nang bahagya, sa halip na ibalot ang ekspresyon sa mga parisukat na tirante, kakailanganin mo na ngayong gumamit ng mga kulot na brace. Makakakuha ka rin ng isang bagong diksyunaryo / itakda ang object sa halip na isang bagong listahan.
data= {'lungsod':'new york', 'pangalan':'john doe'}
naka-format_data= {k: v.pamagat() para sasa,vsadatamga item()}
mag-print (naka-format_data)
Ang halimbawa sa itaas ay magko-convert sa mga halaga ng string sa title case at lilikha ng isang bagong diksyunaryo na tinatawag na formatted_data, na ang output ay magiging: {'city': 'New York', 'name': 'John Doe'}. Maaari mo ring baguhin ang diksyunaryo / itakda sa lugar sa pamamagitan ng pagtukoy ng mayroon nang variable ng diksyunaryo sa kaliwang kamay.
data= {'lungsod':'new york', 'pangalan':'john doe'}data= {k: v.pamagat() para sasa,vsadatamga item()}
mag-print (data)
Nang hindi gumagamit ng mga pag-unawa sa diksyunaryo, ang code ay magiging ganito:
data= {'lungsod':'new york', 'pangalan':'john doe'}naka-format_data= {}
para sasa,vsadatamga item():
naka-format_data[sa] =v.pamagat()
mag-print (naka-format_data)
Dahil walang mga pares ng key-halaga sa mga hanay, ang isang hanay na pag-unawa ay maaaring tukuyin sa parehong paraan bilang isang pagkaunawa sa listahan. Ang pagkakaiba lamang ay ang paggamit ng mga kulot na brace.
Halimbawa: Maramihang Para sa Mga loop sa isang Pag-unawa sa Listahan
Ang halimbawa ng pagkaunawa sa listahan na nabanggit sa itaas ay pangunahing at gumagamit ng solong para sa pahayag. Nasa ibaba ang isang halimbawa na gumagamit ng maraming para sa mga loop at isang kondisyon kung pahayag.
pang-uri= ['Disk', 'Eoan', 'Pokus', 'Maarte']mga hayop= ['Dingo', 'Ermine', 'Ang hukay', 'Beaver']
mga codename= [x +'+ atpara saxsapang-uripara saatsamga hayopkungat.startswith(x[0])]
mag-print (mga codename)
Ipapakita ng code ang ['Disco Dingo', 'Eoan Ermine', 'Focal Fossa'] bilang output. Ang dalawa para sa mga loop ay napupunta sa mga listahan ng adjective at hayop at ang kanilang mga miyembro ay pinagsama gamit ang isang puwang, kung ang unang titik ng parehong mga salita ay pareho. Nang hindi gumagamit ng mga pag-unawa sa listahan, magiging ganito ang code:
pang-uri= ['Disk', 'Eoan', 'Pokus', 'Maarte']mga hayop= ['Dingo', 'Ermine', 'Ang hukay', 'Beaver']
mga codename= []
para saxsaadjectives:
para saatsahayop:
kungat.startswith(x[0]):
mga codename.idugtong(x +'+ at)
mag-print (mga codename)
Halimbawa: Listahan ng Pag-unawa sa if-else na sugnay
Ang halimbawa sa ibaba ay magpapakita ng paggamit ng kung at iba pang mga pahayag sa pag-unawa sa listahan.
number_list= [1, 2, 3, 4]another_list= [5, 6, 7, 8]
resulta= [Totoo kung (x + y)%2 == 0 iba pa Mali para saxsanumber_listpara saatsaanother_list]
mag-print (resulta)
Habang nag-loop sa dalawang listahan, ang pag-unawa sa listahan sa itaas ay sumusuri kung ang kabuuan ng pares ng mga elemento ay pantay o hindi. Ang pagpapatakbo ng code sa itaas ay ipapakita sa iyo [Tama, Mali, Tama, Mali, Mali, Tama, Mali, Tama, Tama, Mali, Tama, Mali, Mali, Tama, Mali, Tama] bilang output. Nang hindi gumagamit ng pag-unawa sa listahan, magiging ganito ang code:
number_list= [1, 2, 3, 4]another_list= [5, 6, 7, 8]
resulta= []
para saxsanumber_list:
para saatsaanother_list:
kung (x + y)%2 == 0:
resultaidugtong(Totoo)
iba pa:
resultaidugtong(Mali)
mag-print (resulta)
Konklusyon
Ang mga pag-unawa sa listahan ay nagbibigay ng isang magandang paraan upang magsulat ng malinis at maigsi na mga pahayag ng loop. Gayunpaman, mabilis silang makakakuha ng kumplikado at mahirap maunawaan kung maraming mga loop at kondisyong pahayag ang ginamit. Sa huli, pagdating sa antas ng kaginhawaan ng isang programmer ngunit sa pangkalahatan magandang ideya na magsulat ng tahasang, nababasa, at madaling i-debug ang code sa halip na labis na paggamit ng mga shorthands.