Nilalaman
Sa proseso ng pag-aaral sa programa, madalas na kinakailangan upang lumikha ng mga programa na hindi gaanong madaling gamitin sa totoong buhay. Pagkatapos ng lahat, paminsan-minsan kailangan mong sundin ang mga tagubilin lamang sa ilalim ng ilang mga kundisyon. Upang maipatupad ito sa programa, ang lahat ng mga wika ay may mga control statement. Sa tulong nila, makokontrol mo ang daloy ng pagpapatupad ng code, paglikha ng mga loop o pagsasagawa ng ilang partikular na pagkilos lamang kapag totoo ang isang partikular na kundisyon.
Ngayon ay pag-uusapan natin ang tungkol sa kung pahayag, na sumusuri sa kasalukuyang sitwasyon para sa isang tiyak na kundisyon, at batay sa impormasyong ito, ay gumagawa ng mga desisyon tungkol sa mga karagdagang aksyon.
Mga Uri ng Control Statement
Sa pangkalahatan, kung hindi lang ang pahayag na kumokontrol sa daloy ng isang programa. Pati na rin siya mismo ay maaaring maging bahagi ng isang mas malaking hanay ng mga operator.
Mayroon ding mga loop at pahayag na kumokontrol sa proseso ng pagpapatupad nito. Ngayon ay pag-uusapan lamang natin ang tungkol sa conditional operator at ang mga kadena kung saan maaari itong lumahok.
Sa programming, mayroong isang bagay bilang sumasanga. Ito ay tiyak na nangangahulugan ng isang pagkakasunud-sunod ng mga utos na isinasagawa lamang kung ang isang tiyak na kundisyon ay totoo. Ang pamantayan mismo ay maaaring magkakaiba:
- Pagkakapantay-pantay ng isang variable sa isang tiyak na halaga.
- Pagsasagawa ng isang tiyak na aksyon.
- Status ng aplikasyon (na-collapse o hindi).
Maaaring mas malaki ang spectrum. Ang mga pahayag na may kondisyon ay may ilang uri:
- Sa isang sangay. Iyon ay, ang isang solong pagsusuri ay isinasagawa, bilang isang resulta kung saan ang ilang mga aksyon ay ginanap.
- May dalawa o higit pang sangay. Kung totoo ang pamantayan 1, suriin ang pamantayan 2. Kung totoo ito, suriin ang 3. At kaya, magsagawa ng maraming pagsusuri kung kinakailangan.
- Sa ilang mga kundisyon. Simple lang ang lahat dito. Sinusuri ng interpreter ang maraming kundisyon o isa sa mga ito.
kung pahayag
Ang istruktura ng if statement ay magkatulad sa lahat ng wika. Gayunpaman, sa Python, ang syntax nito ay medyo naiiba sa lahat ng iba pa:
kung kondisyon:
<входящее выражение 1>
<входящее выражение 2>
<не входящее выражение>
Una, ang operator mismo ay idineklara, pagkatapos ay isinulat ang kondisyon kung saan ito nagsimulang magtrabaho. Ang kundisyon ay maaaring tama o mali.
Sinusundan ito ng isang bloke na may mga utos. Kung ito ay agad na sumusunod sa isang criterion na dapat matugunan, kung gayon ang katumbas na pagkakasunod-sunod ng mga utos ay tinatawag na isang if block. Maaari mong gamitin ang anumang bilang ng mga utos sa loob nito.
Atensyon! Ang indentation sa loob ng lahat kung block command ay dapat na parehong laki. Ang mga hangganan ng block ay tinutukoy ng mga indent.
Ayon sa dokumentasyon ng wika, ang indentasyon ay 4 na puwang.
Paano gumagana ang operator na ito? Kapag nakita ng interpreter ang salitang if, agad nitong sinusuri ang expression laban sa pamantayang tinukoy ng user. Kung ito ang kaso, magsisimula siyang maghanap ng mga tagubilin at sundin ang mga ito. Kung hindi, lahat ng utos mula sa block na ito ay nilaktawan.
Kung ang isang pahayag pagkatapos ng kundisyon ay hindi naka-indent, hindi ito itinuturing bilang isang if block. Sa aming sitwasyon, ang linyang ito ay
Narito ang isang code snippet para sa isang halimbawa kung paano gumagana ang operator na ito.
numero = int(input(“Magpasok ng numero: “))
kung numero > 10:
print("Ang bilang ay higit sa 10")
Ang program na ito ay nag-uudyok sa gumagamit para sa isang numero at sinusuri kung ito ay higit sa 10. Kung gayon, ibinabalik nito ang naaangkop na impormasyon. Halimbawa, kung ipinasok ng gumagamit ang numero 5, pagkatapos ay magtatapos lamang ang programa, at iyon na.
Ngunit kung tinukoy mo ang bilang na 100, mauunawaan ng interpreter na ito ay higit sa sampu, at iulat ito.
Atensyon! Sa aming kaso, kung mali ang kundisyon, hihinto ang programa, dahil walang mga utos na ibinigay pagkatapos ng pagtuturo.
Mayroon lamang isang utos sa code sa itaas. Ngunit marami pa sa kanila. Ang tanging kinakailangan ay mag-indent.
Ngayon suriin natin ang pagkakasunod-sunod ng mga utos.
numero = int(input("Sumulat ng numero:"))
kung numero > 10:
print("unang linya")
print ("pangalawang linya")
print ("ikatlong linya")
print("Ang linya na pinaandar, anuman ang numerong ipinasok")
print("Tapusin ang aplikasyon")
Subukang hulaan kung ano ang magiging output kung ipasok mo ang mga halaga 2, 5, 10, 15, 50.
Tulad ng nakikita mo, kung ang numero na ipinasok ng gumagamit ay higit sa sampu, pagkatapos ay tatlong linya ang output + isa na may tekstong "Run every time ..." at isang "End", at kung mas mababa sa sampu, pagkatapos ay isa lamang, na may ibang text. Ang mga linyang 3,4,5 lamang ang isasagawa kung totoo. Gayunpaman, ang huling dalawang linya ay isusulat kahit anong numero ang tinukoy ng user.
Kung gagamitin mo ang mga pahayag nang direkta sa console, mag-iiba ang resulta. Ino-on kaagad ng interpreter ang multi-line mode kung, pagkatapos tukuyin ang criterion sa pag-verify, pindutin ang Enter.
Ipagpalagay na isinulat namin ang sumusunod na pagkakasunud-sunod ng mga utos.
>>>
>>> n = 100
>>> kung n > 10:
...
Pagkatapos nito, makikita natin na >>> ay napalitan ng ellipsis. Nangangahulugan ito na ang multiline input mode ay pinagana. Sa simpleng salita, kung pinindot mo ang Enter, ililipat ka sa input ng ikalawang yugto ng pagtuturo.
At para makalabas sa block na ito, kailangan mong magdagdag ng isa pang construction sa block if.
>>>
>>> n = 100
>>> kung n > 10:
… print(«nv 10»)
...
Kung hindi totoo ang kundisyon, magtatapos ang programa. Ito ay isang problema, dahil maaaring makita ng gumagamit ang naturang programa bilang sarado dahil sa isang pagkabigo. Samakatuwid, ito ay kinakailangan upang magbigay ng feedback sa gumagamit. Para dito, ginagamit ang isang link kung hindi.
operator ng expression kung hindi
Binibigyang-daan ka ng operator na ito na magpatupad ng isang link: kung ang expression ay tumutugma sa isang partikular na panuntunan, gawin ang mga pagkilos na ito, at kung hindi, pagkatapos ay iba pa. Iyon ay, pinapayagan ka nitong hatiin ang daloy ng programa sa dalawang kalsada. Ang syntax ay intuitive:
kung kondisyon:
# kung block
pahayag 1
pahayag 2
at saka pa
kung hindi:
# iba pang block
pahayag 3
pahayag 4
at iba pa:
Ipaliwanag natin kung paano gumagana ang operator na ito. Una, ang karaniwang pahayag ay isinasagawa sa thread yew, sinusuri kung ito ay tumutugma kalagayan "Tama o mali". Ang mga karagdagang aksyon ay nakasalalay sa mga resulta ng pagsusuri. Kung totoo, ang pagtuturo na nasa pagkakasunud-sunod ng mga tagubilin na sumusunod sa kundisyon ay direktang isinasagawa. yew, kung ito ay hindi totoo, kung gayon iba.
Sa ganitong paraan maaari mong pangasiwaan ang mga error. Halimbawa, kailangan ng user na magpasok ng radius. Malinaw, maaari lang itong numero na may plus sign, o isa itong null value. Kung ito ay mas mababa sa 0, kailangan mong mag-isyu ng mensahe na humihiling sa iyong maglagay ng positibong numero.
Narito ang code na nagpapatupad ng gawaing ito. Ngunit mayroong isang pagkakamali dito. Subukan mong hulaan kung alin.
radius = int(input(“Ipasok ang radius: “))
kung radius >= 0:
print("Circumference = ", 2 * 3.14 * radius)
print(“Lugar = “, 3.14 * radius ** 2)
kung hindi:
print("Mangyaring magpasok ng positibong numero")
Error sa indentation mismatch. Kung ako ay iba dapat na matatagpuan nang wala ang mga ito o may parehong bilang ng mga ito (depende sa kung sila ay nested o hindi).
Magbigay tayo ng isa pang use case (kung saan magiging tama ang lahat sa pagkakahanay ng operator) – isang elemento ng application na sumusuri ng password.
password = input("Ipasok ang password:")
kung password == «sshh»:
print("Welcome")
kung hindi:
print("Tinanggihan ang pag-access")
Nilaktawan pa ng tagubiling ito ang tao kung sshh ang password. Kung may iba pang kumbinasyon ng mga titik at numero, ipinapakita nito ang mensaheng "Tinanggihan ang pag-access".
pahayag-pagpapahayag kung-elif-iba
Kung hindi totoo ang ilang kundisyon, ang pahayag na nasa block ay isasagawa. iba. Ang expression na ito ay gumagana tulad nito.
kung kondisyon_1:
# kung block
pahayag
pahayag
karagdagang pahayag
elif condition_2:
# unang bloke ng elif
pahayag
pahayag
karagdagang pahayag
elif condition_3:
# pangalawang elif block
pahayag
pahayag
karagdagang pahayag
...
iba
pahayag
pahayag
karagdagang pahayag
Maaari mong tukuyin ang anumang bilang ng mga karagdagang kundisyon.
Mga nested na pahayag
Ang isa pang paraan upang magpatupad ng maraming kundisyon ay ang pagpasok ng mga karagdagang pagsusuri sa kundisyon sa if block.
Opereytor if sa loob ng isa pang condition block
gre_score = int(input("Ipasok ang iyong kasalukuyang limitasyon sa kredito"))
per_grad = int(input(“Ipasok ang iyong credit rating: “))
kung per_grad > 70:
# panlabas kung block
kung gre_score > 150:
# panloob kung block
print("Binabati kita, nakatanggap ka ng pautang")
kung hindi:
print("Paumanhin, hindi ka karapat-dapat para sa isang pautang")
Ang program na ito ay nagsasagawa ng pagsusuri sa credit rating. Kung ito ay mas mababa sa 70, ang programa ay nag-uulat na ang gumagamit ay hindi karapat-dapat para sa kredito. Kung ito ay mas malaki, ang isang pangalawang pagsusuri ay isinasagawa upang makita kung ang kasalukuyang limitasyon ng kredito ay higit sa 150. Kung oo, pagkatapos ay isang mensahe ang ipinapakita na ang utang ay naibigay na.
Kung ang parehong mga halaga ay mali, ang isang mensahe ay ipinapakita na ang gumagamit ay walang posibilidad na makakuha ng pautang.
Ngayon, gawin nating muli ang program na iyon.
gre_score = int(input("Ipasok ang kasalukuyang limitasyon:"))
per_grad = int(input(“Ipasok ang credit score: “))
kung per_grad > 70:
kung gre_score > 150:
print("Binabati kita, nakatanggap ka ng pautang")
kung hindi:
print("Mababa ang iyong limitasyon sa kredito")
kung hindi:
print("Paumanhin, hindi ka karapat-dapat para sa kredito")
Ang code mismo ay halos kapareho, ngunit naka-nest if nagbibigay din ng algorithm kung sakaling mali ang kundisyon mula rito. Iyon ay, ang limitasyon sa card ay hindi sapat, ngunit ang kasaysayan ng kredito ay mabuti, ang mensaheng "Mayroon kang mababang credit rating" ay ipinapakita.
if-else na pahayag sa loob ng isang kundisyon iba
Gumawa tayo ng isa pang programa na tumutukoy sa grado ng isang mag-aaral batay sa mga marka ng pagsusulit.
score = int(input(“Ipasok ang iyong marka: “))
kung score >= 90:
print("Magaling! A ang grade mo")
kung hindi:
kung score >= 80:
print("Mahusay! Ang marka mo ay B")
kung hindi:
kung score >= 70:
print("Maganda! Ang grade mo ay C")
kung hindi:
kung score >= 60:
print(“Ang iyong grado ay D. Sulit na ulitin ang materyal.”)
kung hindi:
print("Bumagsak ka sa pagsusulit")
Ang aplikasyon ay unang nagsusuri upang makita kung ang marka ay mas malaki kaysa o katumbas ng 90. Kung oo, pagkatapos ay nagbabalik ito ng isang gradong A. Kung mali ang kundisyong ito, isasagawa ang mga kasunod na pagsusuri. Nakikita namin na ang algorithm ay halos pareho sa unang tingin. Kaya imbes na tingnan ang loob iba mas mahusay na gumamit ng kumbinasyon kung-elif-iba.
Kaya ang operator if gumaganap ng napakahalagang function – tinitiyak nito na ang ilang piraso ng code ay ipapatupad lamang kung may pangangailangan para dito. Imposibleng isipin ang programming nang wala ito, dahil kahit na ang pinakasimpleng algorithm ay nangangailangan ng mga tinidor tulad ng "kung pupunta ka sa kaliwa, makikita mo ito, at kung pupunta ka sa kanan, kailangan mong gawin ito at iyon."