പൈത്തണിൽ ലൂപ്പ് ചെയ്യുമ്പോൾ. ഇത് എങ്ങനെ പ്രവർത്തിക്കുന്നു, ഉപയോഗത്തിന്റെ ഉദാഹരണങ്ങൾ

ഏത് ഭാഷയുടെയും പ്രധാന ഉപകരണങ്ങളിലൊന്നാണ് ലൂപ്പുകൾ. പൈത്തണിൽ രണ്ട് അടിസ്ഥാന ലൂപ്പുകൾ ഉണ്ട്, അതിലൊന്ന് സമയമാണ്. അത് പരിഗണിക്കുക, കൂടാതെ ചിത്രത്തെ നന്നായി മനസ്സിലാക്കാൻ, ഒന്ന് കൂടി. തീർച്ചയായും, സമാനമായ ഒന്നുമായി താരതമ്യപ്പെടുത്തുമ്പോൾ, ഏത് മെറ്റീരിയലും മനസ്സിലാക്കുന്നത് വളരെ എളുപ്പമാണ്, അല്ലേ?

ഒരു ചക്രം എന്ന ആശയം

ഒരു നിശ്ചിത പ്രവർത്തനം ഒന്നിലധികം തവണ നടത്തേണ്ടിവരുമ്പോൾ ഒരു ലൂപ്പ് ആവശ്യമാണ്. ഇത് വളരെ ലളിതമാണ്, കാരണം വാസ്തവത്തിൽ സൈക്കിളുകൾക്കുള്ള ആപ്ലിക്കേഷനുകളുടെ ശ്രേണി വളരെ വിശാലമാണ്. പൈത്തണിൽ പ്രധാനമായും രണ്ട് തരം ലൂപ്പുകൾ ഉണ്ട്: അതിനുള്ളതും സമയവും. ഏറ്റവും ജനപ്രിയമായത്.

നിർദ്ദിഷ്ട പ്രവർത്തനങ്ങൾക്ക് പുറമേ, നിങ്ങൾക്ക് ഒരു നിശ്ചിത പോയിന്റ് വരെ വ്യത്യസ്ത കോഡ് കഷണങ്ങൾ ലൂപ്പ് ചെയ്യാം. ഇത് ഒരു നിശ്ചിത എണ്ണം തവണ ആകാം, അല്ലെങ്കിൽ ഒരു പ്രത്യേക വ്യവസ്ഥ ശരിയാകുന്നിടത്തോളം.

ലൂപ്പുകളുടെ തരങ്ങൾ മനസിലാക്കാൻ തുടങ്ങുന്നതിനുമുമ്പ്, പ്രത്യേകിച്ചും, ആവർത്തനം എന്താണെന്ന് നമ്മൾ ഇപ്പോഴും മനസ്സിലാക്കേണ്ടതുണ്ട്. നിലവിലെ ആപ്ലിക്കേഷൻ റണ്ണിനുള്ളിലെ നിലവിലെ സൈക്കിളിലെ ഒരു പ്രവർത്തനത്തിന്റെ അല്ലെങ്കിൽ പ്രവർത്തനങ്ങളുടെ ക്രമത്തിന്റെ ഒരു ആവർത്തനമാണിത്.

ഇതിനായി സൈക്കിൾ

മറ്റു പല ഭാഷകളിലേയും പോലെ ഞങ്ങളുടെ ഫോർ ലൂപ്പ് ഒരു കൗണ്ടറല്ല. മൂല്യങ്ങളുടെ ഒരു നിശ്ചിത ശ്രേണി കണക്കാക്കുക എന്നതാണ് ഇതിന്റെ ചുമതല. എന്താണ് ഇതിന്റെ അര്ഥം? നമുക്ക് ഘടകങ്ങളുടെ ഒരു ലിസ്റ്റ് ഉണ്ടെന്ന് പറയാം. ആദ്യം, ലൂപ്പ് ആദ്യത്തേത്, രണ്ടാമത്തേത്, മൂന്നാമത്തേത്, മുതലായവ എടുക്കുന്നു.

പൈത്തണിലെ ഈ ലൂപ്പിന്റെ പ്രയോജനം, എപ്പോൾ ലൂപ്പിൽ നിന്ന് പുറത്തുകടക്കണമെന്ന് അറിയാൻ നിങ്ങൾ മൂലകത്തിന്റെ സൂചിക നിർണ്ണയിക്കേണ്ടതില്ല എന്നതാണ്. എല്ലാം യാന്ത്രികമായി ചെയ്യും.

>>> spisok = [10, 40, 20, 30]

>>> spisok ലെ മൂലകത്തിന്:

… പ്രിന്റ് (ഘടകം + 2)

പങ്ക് € |

12

42

22

32

ഞങ്ങളുടെ ഉദാഹരണത്തിൽ, ഞങ്ങൾ വേരിയബിൾ ഉപയോഗിച്ചു മൂലകം ഫോർ കമാൻഡിന് ശേഷം. പൊതുവേ, പേര് എന്തും ആകാം. ഉദാഹരണത്തിന്, ഒരു ജനപ്രിയ പദവി i. ഓരോ ആവർത്തനത്തിലും, ഈ വേരിയബിളിന് ലിസ്റ്റിൽ നിന്ന് ഒരു നിർദ്ദിഷ്ട ഒബ്ജക്റ്റ് നൽകും, അതിനെ ഞങ്ങൾ ഉചിതമായ വാക്ക് എന്ന് വിളിക്കുന്നു.

ഞങ്ങളുടെ കാര്യത്തിൽ, പട്ടിക 10,40,20,30 സംഖ്യകളുടെ ഒരു ശ്രേണിയാണ്. ഓരോ ആവർത്തനത്തിലും, അനുബന്ധ മൂല്യം വേരിയബിളിൽ ദൃശ്യമാകും. ഉദാഹരണത്തിന്, ലൂപ്പ് ആരംഭിക്കുമ്പോൾ തന്നെ, വേരിയബിൾ മൂലകം മൂല്യം 10 ​​നിയുക്തമാക്കിയിരിക്കുന്നു. അടുത്ത ആവർത്തനത്തിൽ, പത്ത് സംഖ്യ 40 ആയി മാറുന്നു, മൂന്നാം തവണ അത് 20 എന്ന സംഖ്യയായി മാറുന്നു, ഒടുവിൽ, ലൂപ്പിന്റെ അവസാന ആവർത്തനത്തിൽ, അത് 30 ആയി മാറുന്നു.

സൈക്കിൾ അവസാനിക്കുന്നതിനുള്ള സിഗ്നൽ പട്ടികയിലെ മൂലകങ്ങളുടെ അവസാനമാണ്.

മറ്റ് പ്രോഗ്രാമിംഗ് ഭാഷകളിലെന്നപോലെ, മൂല്യങ്ങളുടെ ഒരു ക്ലാസിക് എൻയുമറേഷൻ നടത്താൻ നിങ്ങൾക്ക് ലൂപ്പ് ആവശ്യമുണ്ടെങ്കിൽ, നമുക്ക് ആവശ്യമുള്ള മൂല്യം വരെയുള്ള സ്വാഭാവിക സംഖ്യകളുടെ ഒരു ശ്രേണി നിങ്ങൾ സൃഷ്ടിക്കണം.

>>> spisok = [1,2,3,4,5]

അല്ലെങ്കിൽ ഫംഗ്ഷൻ ഉപയോഗിക്കുക ലെൻ(), പട്ടികയുടെ ദൈർഘ്യം നിർണ്ണയിക്കാൻ. എന്നാൽ ഈ സാഹചര്യത്തിൽ ഒരു ലൂപ്പ് ഉപയോഗിക്കുന്നതാണ് നല്ലത് അതേസമയം, കാരണം ഒരു വേരിയബിൾ ഉപയോഗിക്കേണ്ട ആവശ്യമില്ല.

ലിസ്റ്റിലെ മൂല്യങ്ങളുടെ ക്രമം നിങ്ങൾക്ക് മാറ്റണമെങ്കിൽ, ലൂപ്പ് ചെയ്യുക വേണ്ടി ഇവിടെ രക്ഷാപ്രവർത്തനത്തിന് വരുന്നു. ഇത് ചെയ്യുന്നതിന്, ഓരോ ആവർത്തനത്തിലും, ലിസ്റ്റിലെ ഓരോ ഘടകത്തിനും ഉചിതമായ മൂല്യം നൽകണം.

ലൂപ്പ് ആയിരിക്കുമ്പോൾ

സൈക്കിളിൽ നിന്ന് വ്യത്യസ്തമായി വേണ്ടി, ഇത് സീക്വൻസിന്റെ മൂല്യങ്ങൾ, ലൂപ്പ് എന്നിവയിൽ ലളിതമായി ആവർത്തിക്കുന്നു സമയത്ത് കൂടുതൽ ഉപയോഗങ്ങളുണ്ട്. ഇത്തരത്തിലുള്ള സൈക്കിളുകളുടെ പേര് "ഇതുവരെ" എന്ന് വിവർത്തനം ചെയ്യപ്പെടുന്നു. അതായത്, "വരെ".

എല്ലാ പ്രോഗ്രാമിംഗ് ഭാഷകളിലും കാണപ്പെടുന്ന ഒരു സാർവത്രിക ലൂപ്പാണിത്. ചില വഴികളിൽ ഇത് ഒരു സോപാധിക ഓപ്പറേറ്ററോട് സാമ്യമുള്ളതാണ് യൂ, ഒരു നിശ്ചിത വ്യവസ്ഥ പാലിക്കുന്നുണ്ടോ എന്നറിയാൻ ഒരു പരിശോധന നടത്തുന്നു. സോപാധിക ഓപ്പറേറ്റർക്ക് വിപരീതമായി മാത്രം, സമയത്ത് ഒരിക്കൽ മാത്രമല്ല, ഓരോ ആവർത്തനത്തിലും പരിശോധന നടത്തുന്നു. വ്യവസ്ഥ തെറ്റാണെങ്കിൽ മാത്രം, ലൂപ്പ് അവസാനിക്കുകയും അതിനെ പിന്തുടരുന്ന കമാൻഡ് എക്സിക്യൂട്ട് ചെയ്യുകയും ചെയ്യുന്നു. ലളിതമായി പറഞ്ഞാൽ, അവൻ ജോലി ചെയ്യുന്ന സാഹചര്യം ഇനി സാധുവല്ലെങ്കിൽ.

നമ്മൾ ഒരു സൈക്കിൾ വരച്ചാൽ സമയത്ത് ലളിതമായി പറഞ്ഞാൽ, അത്തരമൊരു സ്കീം ഉപയോഗിച്ചാണ് ഇത് ചെയ്യുന്നത്.പൈത്തണിൽ ലൂപ്പ് ചെയ്യുമ്പോൾ. ഇത് എങ്ങനെ പ്രവർത്തിക്കുന്നു, ഉപയോഗത്തിന്റെ ഉദാഹരണങ്ങൾ

പ്രോഗ്രാമിന്റെ പ്രധാന ശാഖ (ലൂപ്പിന് പുറത്ത് പ്രവർത്തിക്കുന്നു) ഈ ചിത്രത്തിൽ നീല ദീർഘചതുരങ്ങളോടെ ചിത്രീകരിച്ചിരിക്കുന്നു. ടർക്കോയ്സ് സൈക്കിളിന്റെ ശരീരത്തെ പ്രതിനിധീകരിക്കുന്നു. അതാകട്ടെ, ഓരോ ആവർത്തനത്തിലും പരിശോധിക്കപ്പെടുന്ന ഒരു അവസ്ഥയാണ് റോംബസ്.

സൈക്കിൾ സമയത്ത് രണ്ട് ഒഴിവാക്കലുകൾക്ക് കാരണമാകാം:

  1. ലൂപ്പിന്റെ തുടക്കത്തിൽ ലോജിക്കൽ എക്സ്പ്രഷൻ ശരിയാകുന്നില്ലെങ്കിൽ, എക്സിക്യൂഷന് മുമ്പ് പൂർത്തിയാക്കിയ ശേഷം അത് ആരംഭിക്കുന്നില്ല. പൊതുവേ, ഈ സാഹചര്യം സാധാരണമാണ്, കാരണം ചില സാഹചര്യങ്ങളിൽ, ലൂപ്പ് ബോഡിയിലെ എക്സ്പ്രഷനുകളുടെ സാന്നിധ്യം ആപ്ലിക്കേഷൻ നൽകിയേക്കില്ല.
  2. പദപ്രയോഗം എല്ലായ്പ്പോഴും ശരിയാണെങ്കിൽ, ഇത് ഒരു ലൂപ്പിലേക്ക് നയിച്ചേക്കാം. അതായത്, സൈക്കിളിന്റെ അനന്തമായ സ്ക്രോളിംഗിലേക്ക്. അതിനാൽ, അത്തരം പ്രോഗ്രാമുകളിൽ, എല്ലായ്പ്പോഴും ലൂപ്പിൽ നിന്നോ പ്രോഗ്രാമിൽ നിന്നോ ഒരു എക്സിറ്റ് സ്റ്റേറ്റ്മെന്റ് ഉണ്ടായിരിക്കണം. എന്നിരുന്നാലും, ഒരു പ്രത്യേക വ്യവസ്ഥയുടെ സത്യമോ തെറ്റോ നിർണ്ണയിക്കാൻ പ്രോഗ്രാമിന് കഴിയുമെങ്കിൽ ഈ സാഹചര്യം ഉടലെടുക്കും. അവൾ ഇത് ചെയ്യുന്നതിൽ പരാജയപ്പെട്ടാൽ, പ്രോഗ്രാം അവസാനിപ്പിക്കുന്നതിനൊപ്പം ഒരു പിശക് തിരികെ ലഭിക്കും. അല്ലെങ്കിൽ നിങ്ങൾക്ക് പിശക് കൈകാര്യം ചെയ്യാൻ കഴിയും, തുടർന്ന്, അത് സംഭവിക്കുകയാണെങ്കിൽ, ചില കോഡ് എക്സിക്യൂട്ട് ചെയ്യും.

ഒരു പിശക് എങ്ങനെ കൈകാര്യം ചെയ്യാമെന്നതിന് ധാരാളം ഓപ്ഷനുകൾ ഉണ്ടാകാം. ഉദാഹരണത്തിന്, ഡാറ്റ ശരിയായി നൽകാൻ പ്രോഗ്രാം ഉപയോക്താവിനോട് ആവശ്യപ്പെട്ടേക്കാം. അതിനാൽ, ഒരു വ്യക്തി പോസിറ്റീവ് ആയിരിക്കാവുന്ന ഒരു നെഗറ്റീവ് നമ്പർ സൂചിപ്പിക്കുകയോ അല്ലെങ്കിൽ അക്കങ്ങൾ മാത്രമുള്ള അക്ഷരങ്ങൾ നൽകുകയോ ചെയ്താൽ, പ്രോഗ്രാമിന് അതിനെക്കുറിച്ച് പറയാൻ കഴിയും.

അതേസമയം ലൂപ്പ് ഉദാഹരണങ്ങൾ

ഈ കേസിൽ ഒരു പിശക് കൈകാര്യം ചെയ്യുന്ന കോഡിന്റെ ഒരു ഉദാഹരണം ഇതാ.

n = ഇൻപുട്ട് ("ഒരു പൂർണ്ണസംഖ്യ നൽകുക:") 

ടൈപ്പ്(n) != int:

    ശ്രമിക്കുക:

        n = int(n)

    മൂല്യം പിശക് ഒഴികെ:

        പ്രിന്റ് ("തെറ്റായ എൻട്രി!")

        n = ഇൻപുട്ട് ("ഒരു പൂർണ്ണസംഖ്യ നൽകുക:") 

n % 2 == 0 ആണെങ്കിൽ:

    പ്രിന്റ് ("പോലും")

വേറെ:

    പ്രിന്റ് ("വിചിത്രം")

സങ്കീർണ്ണമായ കോഡ് നിർമ്മിതികൾ പ്രഖ്യാപിക്കാൻ പൈത്തൺ കോളണുകൾ ഉപയോഗിക്കുന്നുണ്ടെന്ന് ഓർമ്മിക്കുക.

മുകളിലുള്ള കോഡിൽ, നമ്പർ ഒരു പൂർണ്ണസംഖ്യയാണോ എന്ന് പരിശോധിക്കേണ്ട ഒരു വ്യവസ്ഥയായി ഞങ്ങൾ നിർവചിച്ചു. ഉണ്ടെങ്കിൽ, തെറ്റ് തിരികെ നൽകും. ഇല്ലെങ്കിൽ ശരിയാണ്.

കോഡിന്റെ രണ്ടാം ഭാഗത്ത്, ഓപ്പറേറ്റർ ഉപയോഗിക്കുന്നിടത്ത് if, ഡിവിഷൻ ഓപ്പറേഷന് ശേഷം ബാക്കിയുള്ളത് കണ്ടെത്താൻ ഞങ്ങൾ % ഓപ്പറേറ്റർ ഉപയോഗിച്ചു. അടുത്ത ഘട്ടം നമ്പർ തുല്യമാണോ എന്ന് പരിശോധിക്കുകയാണ്. ഇല്ലെങ്കിൽ, ഈ കേസിൽ ബാക്കിയുള്ളത് ഒന്നാണ്. അതനുസരിച്ച്, സംഖ്യ വിചിത്രമാണ്. 

ലളിതമായി പറഞ്ഞാൽ, ഉപയോക്താവ് നൽകിയ സ്ട്രിംഗ് ഒരു സംഖ്യയാണോ എന്ന് മുകളിലെ കോഡ് ആദ്യം പരിശോധിക്കുന്നു. ഉവ്വ് എങ്കിൽ, രണ്ടായി വിഭജനം ബാക്കിയുണ്ടോ എന്നറിയാൻ രണ്ടാമത്തെ പരിശോധന നടത്തുന്നു. എന്നാൽ ഉപയോക്താവ് നൽകിയ മൂല്യം സംഖ്യയാകുന്നതുവരെ രണ്ടാമത്തെ ബ്ലോക്ക് എക്സിക്യൂട്ട് ചെയ്യില്ല.

അതായത്, അവസ്ഥ ഉണ്ടാകുന്നതുവരെ ലൂപ്പ് പതിവായി നടപ്പിലാക്കും. ഈ സാഹചര്യത്തിൽ, ഇത് ഇതുപോലെ പ്രവർത്തിക്കുന്നു. 

അതായത്, നിങ്ങൾക്ക് വിപരീതത്തിൽ നിന്ന് പോകാം: ഇവന്റ് തെറ്റാകുന്നതുവരെ ഒരു നിശ്ചിത പ്രവർത്തനം ലൂപ്പ് ചെയ്യുക.

കോഡ് പാഴ്‌സിംഗ്

ഈ കോഡ് എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്ന് ഇപ്പോൾ കൂടുതൽ വിശദമായി നോക്കാം. ഇത് ചെയ്യുന്നതിന്, ഞങ്ങൾ അത് ഘട്ടം ഘട്ടമായി വിശകലനം ചെയ്യും.

  1. ആദ്യം, ഉപയോക്താവ് ഒരു സ്ട്രിംഗിൽ പ്രവേശിക്കുന്നു, അത് n എന്ന വേരിയബിൾ സ്വീകരിക്കുന്നു. 
  2. ഒരു ലൂപ്പ് ഉപയോഗിക്കുന്നു സമയത്ത് ഈ വേരിയബിളിന്റെ തരം പരിശോധിച്ചു. ആദ്യ എൻട്രിയിൽ, ഇത് തുല്യമല്ല int. അതിനാൽ, പരിശോധനയുടെ ഫലമായി, ഈ അവസ്ഥ ശരിയാണെന്ന് കണ്ടെത്തി. അതിനാൽ, ലൂപ്പ് ബോഡി പ്രവേശിച്ചു.
  3. ഒരു ഓപ്പറേറ്ററുടെ സഹായത്തോടെ ശ്രമിക്കൂ ഞങ്ങൾ ഒരു സ്ട്രിംഗ് ഒരു സംഖ്യയിലേക്ക് പരിവർത്തനം ചെയ്യാൻ ശ്രമിക്കുകയാണ്. ഇത് ചെയ്താൽ, ഒരു പിശകും സംഭവിക്കുന്നില്ല. അതനുസരിച്ച്, അത് പ്രോസസ്സ് ചെയ്യേണ്ട ആവശ്യമില്ല. അതിനാൽ, വ്യാഖ്യാതാവ് ലൂപ്പിന്റെ തുടക്കത്തിലേക്ക് മടങ്ങുന്നു, പരിശോധനയുടെ ഫലങ്ങൾ അനുസരിച്ച്, അത് ഒരു പൂർണ്ണസംഖ്യയായി മാറിയെന്ന് മാറുന്നു. അതിനാൽ നമുക്ക് സ്റ്റെപ്പ് 7 ലേക്ക് പോകാം
  4. പരിവർത്തനം വിജയിച്ചില്ലെങ്കിൽ, ഒരു മൂല്യ പിശക് എറിയപ്പെടും. ഈ സാഹചര്യത്തിൽ, പ്രോഗ്രാം ഒഴുക്ക് ഒഴികെയുള്ള ഹാൻഡ്‌ലറിലേക്ക് അയയ്ക്കുന്നു.
  5. ഉപയോക്താവ് ഒരു പുതിയ മൂല്യം നൽകുന്നു, അത് n എന്ന വേരിയബിളിന് നൽകിയിരിക്കുന്നു.
  6. വ്യാഖ്യാതാവ് ഘട്ടം 2-ലേക്ക് മടങ്ങുകയും വീണ്ടും പരിശോധിക്കുകയും ചെയ്യുന്നു. ഇതൊരു പൂർണ്ണസംഖ്യ മൂല്യമാണെങ്കിൽ, ഘട്ടം 7-ലേക്ക് പോകുക. ഇല്ലെങ്കിൽ, ഘട്ടം 3 അനുസരിച്ച് പരിവർത്തനം വീണ്ടും ശ്രമിക്കും.
  7. ഒരു ഓപ്പറേറ്ററുടെ സഹായത്തോടെ if ഒരു സംഖ്യയെ 2 കൊണ്ട് ഹരിച്ചതിന് ശേഷം ബാക്കിയുണ്ടോ എന്ന് നിർണ്ണയിക്കുന്നു. 
  8. ഇല്ലെങ്കിൽ, "പോലും" എന്ന വാചകം തിരികെ നൽകും.
  9. ഇല്ലെങ്കിൽ, "ഒറ്റ" എന്ന വാചകം തിരികെ നൽകും.

ഇപ്പോൾ അത്തരമൊരു ഉദാഹരണം പരിഗണിക്കുക. ഈ ചക്രം എത്ര തവണ കടന്നുപോകുമെന്ന് നിർണ്ണയിക്കാൻ ശ്രമിക്കുക?

ആകെ = 100 

i = 0

ഞാൻ <5:

    n = int(ഇൻപുട്ട്())

    ആകെ = ആകെ - n

    i = i + 1 

പ്രിന്റ് ("ബാക്കിയുള്ളത്", ആകെ)

ശരിയായ ഉത്തരം 5. തുടക്കത്തിൽ, വേരിയബിളിന്റെ മൂല്യം i - പൂജ്യം. വേരിയബിൾ തുല്യമാണോ എന്ന് വ്യാഖ്യാതാവ് പരിശോധിക്കുന്നു i 4 അല്ലെങ്കിൽ അതിൽ കുറവ്. അതെ എങ്കിൽ, മൂല്യം തിരികെ നൽകും. യഥാർഥ, അതനുസരിച്ച് ലൂപ്പ് എക്സിക്യൂട്ട് ചെയ്യുന്നു. മൂല്യം ഒന്നായി വർദ്ധിച്ചു.

ആദ്യ ആവർത്തനത്തിനു ശേഷം, വേരിയബിളിന്റെ മൂല്യം 1 ആയി മാറുന്നു. ഒരു പരിശോധന നടത്തുന്നു, ഈ സംഖ്യ വീണ്ടും 5-ൽ കുറവാണെന്ന് പ്രോഗ്രാം മനസ്സിലാക്കുന്നു. അതനുസരിച്ച്, ലൂപ്പ് ബോഡി രണ്ടാം തവണയും നടപ്പിലാക്കുന്നു. ഘട്ടങ്ങൾ സമാനമായതിനാൽ, മൂല്യവും ഒന്നായി വർദ്ധിച്ചു, കൂടാതെ വേരിയബിൾ ഇപ്പോൾ 2 ന് തുല്യമാണ്.

ഈ മൂല്യവും അഞ്ചിൽ താഴെയാണ്. തുടർന്ന് ലൂപ്പ് മൂന്നാം തവണയും എക്സിക്യൂട്ട് ചെയ്യുന്നു, വേരിയബിളിലേക്ക് ചേർത്തു i 1, അതിന് മൂല്യം നൽകിയിരിക്കുന്നു 3. ഇത് വീണ്ടും അഞ്ചിൽ താഴെയാണ്. അതിനാൽ ഇത് ലൂപ്പിന്റെ ആറാമത്തെ ആവർത്തനത്തിലേക്ക് വരുന്നു, അതിൽ വേരിയബിളിന്റെ മൂല്യം i 5 ന് തുല്യമാണ് (എല്ലാത്തിനുമുപരി, ഇത് യഥാർത്ഥത്തിൽ പൂജ്യമായിരുന്നു, നമ്മൾ ഓർക്കുന്നിടത്തോളം). അതനുസരിച്ച്, ഈ അവസ്ഥ പരിശോധനയിൽ വിജയിക്കില്ല, കൂടാതെ ലൂപ്പ് സ്വപ്രേരിതമായി അവസാനിപ്പിക്കുകയും അതിന് പുറത്തുള്ള അടുത്ത ഘട്ടത്തിലേക്കുള്ള മാറ്റം (അല്ലെങ്കിൽ പ്രോഗ്രാം അവസാനിപ്പിക്കൽ, ഇനിപ്പറയുന്ന ഘട്ടങ്ങൾ നൽകിയിട്ടില്ലെങ്കിൽ) നടപ്പിലാക്കുകയും ചെയ്യുന്നു.

സൈക്കിൾ വിപരീത ദിശയിലും സംഭവിക്കാം. ഓരോ തുടർന്നുള്ള ആവർത്തനത്തിലും, വേരിയബിളിന്റെ നിലവിലെ മൂല്യത്തിൽ നിന്ന് ഒന്ന് കുറയ്ക്കുന്ന കോഡിന്റെ ഒരു ഉദാഹരണം ഇതാ. 

ആകെ = 100 

ആകെ > 0:

    n = int(ഇൻപുട്ട്())

    ആകെ = ആകെ - n 

പ്രിന്റ് ("വിഭവം തീർന്നു")

ഈ പ്രോഗ്രാം എന്താണ് ചെയ്യുന്നതെന്ന് ഊഹിക്കാൻ ശ്രമിക്കുക! അത് ഒരു വേരിയബിളിൽ സങ്കൽപ്പിക്കുക മൊത്തം പ്രോഗ്രാം ഉറവിടത്തെക്കുറിച്ചുള്ള വിവരങ്ങൾ സംഭരിച്ചിരിക്കുന്നു. ഓരോ തവണയും വ്യാഖ്യാതാവ് ഉറവിടം ഉണ്ടോ എന്ന് പരിശോധിക്കുന്നു. ഇല്ലെങ്കിൽ, "റിസോഴ്സ് തീർന്നു" എന്ന വാചകം പ്രദർശിപ്പിക്കുകയും പ്രോഗ്രാം അടയ്ക്കുകയും ചെയ്യും. ലൂപ്പിന്റെ ഓരോ ആവർത്തനത്തിലും, ഉപയോക്താവ് വ്യക്തമാക്കുന്ന സംഖ്യ അനുസരിച്ച് ഉറവിടം കുറയുന്നു.

ഇപ്പോൾ ഗൃഹപാഠം. മുകളിലെ കോഡ് മാറ്റാൻ ശ്രമിക്കുക, അതുവഴി വേരിയബിളിന് ശാരീരികമായി നെഗറ്റീവ് ആകാൻ കഴിയില്ല. 

3 അഭിപ്രായങ്ങള്

നിങ്ങളുടെ അഭിപ്രായങ്ങൾ രേഖപ്പെടുത്തുക