പൈത്തൺ പ്രോഗ്രാമിങ് ഭാഷ: കണ്ണിയും

പൈത്തൺ പ്രോഗ്രാമിംഗ് ഭാഷ ( "പെരുമ്പാമ്പ്" അല്ലെങ്കിൽ "പെരുമ്പാമ്പ്" പോലെ) ചില നടപടി ലൂപ്പ് നിരവധി വഴികളുണ്ട്. പൈത്തണിലാണ് ഏതെങ്കിലും ആവർത്തന നടപ്പാക്കുന്നതിനായി പ്രധാന ഉപകരണങ്ങൾ - അതേസമയം ലൂപ്പുകളുടെയും വേണ്ടി. അതേസമയം ലൂപ്പ് വേണ്ടി കൂടുതൽ സാർവത്രിക അതിനെ അലിയുകയുള്ളൂ. എന്നാൽ, ഇത് നല്ലത് ഇതിനർത്ഥമില്ല! അതിനെ മൾട്ടി-ലെവലിലേയും മ്നൊഗൊഉസ്ലൊവ്ംയ്ഹ് പരിപാടികളുടെ സൃഷ്ടി ഏറ്റവും പ്രയാസമുള്ള ജോലികൾ മനസ്സിലായി കാരണം ലൂപ്പ് വേണ്ടി, പലപ്പോഴും ഉപയോഗിക്കുന്നു.

Python: പൊസ്ത്ചൊംദിതിഒന് കൂടെ സൈക്കിൾ

പൊസ്ത്ചൊംദിതിഒന് ഉപയോഗിച്ച് സൈക്കിളുകൾ - അത് കണ്ണിയും സമയത്ത്, ഏറ്റവും യൂണിവേഴ്സൽ സംഘടനാ ഘടനകൾ ആയ പ്രോഗ്രാമിങ് പരിസ്ഥിതിയും. സമയത്ത് ലൂപ്പ് "കാലം" സിദ്ധാന്തം പ്രവർത്തിക്കുന്ന. ഈ താഴെ ഇതിനർത്ഥം: ഒരു അവസ്ഥ ഒരു യഥാർത്ഥ മൂല്യം മടക്കി, അത് പ്രവർത്തിക്കും! ച്യ്ച്ലിചല്ല്യ് ആവർത്തിച്ചു പ്രവർത്തനത്തിനും മാനേജ്മെന്റ്, പ്രാരംഭ മൂല്യം കൂടി ആരംഭിക്കുന്ന കാരണം ഈ ഡിസൈൻ ഒരു "ചക്രം" വിളിക്കുന്നു. ചക്രത്തിൽ ഔട്ട് പൈഥൺ മൂല്യം തെറ്റായ സമയത്ത് സമയത്ത് നടപ്പാക്കുക സമയത്ത്. ഈ സമയത്ത്, ദ്വിഭാഷിയായിരുന്ന താഴെ ഫങ്ഷണൽ-വേറൊരു വിഭാഗത്തിലെ പ്രോഗ്രാം പ്രേഷണം, അതേസമയം പൊസ്ത്ചൊംദിതിഒന് കൂടെ തടയൽ ശേഷം സ്ഥിതിചെയ്യുന്ന പുതിയ ലൈൻ, അതായത്.

പ്രോഗ്രാമിംഗ് ഭാഷകളിൽ, പൊസ്ത്ചൊംദിതിഒന് അതേസമയം പൈഥൺ ചക്രങ്ങൾ താഴെ സിന്റാക്സ് ഉണ്ട്:

1. സമയത്ത് (അവസ്ഥ): 2. പദപ്രയോഗം

എക്സ്പ്രഷൻ ഒരു പ്രസ്താവന അല്ലെങ്കിൽ നിരവധി ആകാം. അവസ്ഥ എപ്പോഴും ഏതെങ്കിലും നോൺ-പൂജ്യം ഒരു യഥാർത്ഥ പ്രാധാന്യം ആണ്. ഈ ഡിസൈൻ കാലത്തോളം അവസ്ഥ പോലെ പ്രവർത്തിക്കുന്നു.

ഉദാഹരണത്തിന് "പൈത്തൺ" സമയത്ത് ചക്രം ഉപയോഗിച്ച്

രഷ്മൊതിരിമ് ലൂപ്പ് സമയത്ത്. പെരുമ്പാമ്പ് വളരെ രസകരമായ ഘടനകൾ അതിന്റെ എത്ര iterations ആണ്:

ഒരു = 0 ഒരു സമയത്ത് <7: പ്രിന്റ് ( "എ") ഒരു = എ + 1

നാം വേരിയബിൾ പ്രഖ്യാപിച്ചു "A", പൂജ്യം അവളെ ചോദിച്ചിട്ടില്ല. അപ്പോൾ അവസ്ഥ വെച്ചു "ഒരു <7 അതേസമയം", ആ, വേരിയബിൾ സമയത്ത് "ഒരു" ആണ് കുറവാണ് നമ്പർ "7", പിന്നെ നമ്മുടെ ലൂപ്പ് കാലത്തോളം തെറ്റായ അവിടെ വധശിക്ഷ ചെയ്യും.

ഒരു തെറ്റായ (എന്നതാണ്, സൈക്കിൾ നിന്ന് പുറത്തു വരും) വേരിയബിൾ നമ്പർ "7" വലുതായിരിക്കും എന്നു എപ്പോഴായിരിക്കും അത്. ഇത് സംഭവിക്കാൻ, ഇത് ഒരു "= എ + 1" ൽ സൂചിപ്പിച്ചിരിക്കുന്ന, 1 യുടെ ഓരോ സമയം.

ഈ നിർമ്മാണ ഉണ്ടാവുകയാണെങ്കിൽ, കത്ത് "ഒരു" 7 തവണ നിര കാണിക്കും!

ഒരു ഒരു ഒരു ഒരു ഒരു ഒരു ഒരു

പൈത്തണിലാണ് സമയത്ത് അതിരുകളില്ലാത്ത ലൂപ്പ്

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

അനന്ത ലൂപ്പ് പലപ്പോഴും ഒരു മാറ്റം ചക്രം അവസ്ഥ ചേർക്കാൻ മറക്കരുത് ഒരു തെറ്റ് ആണാണോ പ്രോഗ്രാമർമാർ ആണ്.

ന്റെ പൈത്തൺ കോഡിൻറെ ഭാഗം ഒരു ചിന്തിക്കാം. ഈ കേസിൽ ചക്രങ്ങൾ ( "#" പ്രതീകം ഒരു അഭിപ്രായം ശേഷം) അനിശ്ചിതമായി ഇതെരതെദ്:

നമ്പർ = 1 # ഒരു വേരിയബിൾ എണ്ണം അത് 1 ഒരു മൂല്യം നിയോഗിക്കുകയോ # കുറവ് 10 നമ്പർ ഏതാണെന്ന് പൊസ്ത്ചൊംദിതിഒന്, സൃഷ്ടിക്കാൻ: എണ്ണം <10 സമയത്ത് പ്രിന്റ് 'ഹലോ' # അവസ്ഥ (പ്രിന്റ് «ഹലോ» സന്ദേശം)

അത് അനിശ്ചിതമായി പ്രവർത്തിക്കേണ്ടത് കാരണം അത്തരം ഒരു പ്രോഗ്രാം, സമാഹരിക്കാൻ തിരക്കുകൂട്ടരുത് പാടില്ല. നാം ഒരിക്കലും ആ തെറ്റ് മൂല്യങ്ങൾ അവസ്ഥ «എണ്ണം <10" ഈ കേസിൽ എപ്പോഴും സത്യം, അങ്ങനെ ആവർത്തന നിരന്തരം ഓഫ് എൻ-ാം എണ്ണം ചെയ്യും "ഹലോ" സന്ദേശങ്ങൾ നിബന്ധനകൾ ചോദിച്ചു. നിത്യ കംപൈൽ പ്രക്രിയ ആരംഭിക്കുന്നതിന്, നിങ്ങൾ ഷെൽ കീ കോമ്പിനേഷൻ കണ്ട്രോൾ + സി അമർത്തുക ചെയ്യേണ്ടതുണ്ട്.

Python: വാക്യഘടന. അതേസമയം, കണ്ണി വേണ്ടി

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

വേണ്ടി സൈക്കിൾ നേരിടുന്ന വെല്ലുവിളികൾ എന്തൊക്കെയാണ്? തീർച്ചയായും സമയത്ത് അതേ - ഏതെങ്കിലും പ്രക്രിയകൾ ഇതെരതെ. "പൈത്തൺ" ഉണ്ടാക്കി പ്രോഗ്രാം കുറിപ്പുകൾ, മൂലകങ്ങളുടെ സഞ്ചാരം നിശ്ചയിച്ചിട്ടുള്ള ചതുരശ്രയടി നടപ്പിലാക്കുന്ന അവരെ അതിന്റെ വിവിധ ശരീരം ആവർത്തിക്കുന്നതുമല്ല പ്രകടനം കഴിവുള്ള ഏത്, പരക്കെ ഉപയോഗിക്കുന്ന ലൂപ്പ് ആണ്. ഈ ഡിസൈൻ സവിശേഷതകൾ പ്രോസസ്സിംഗ് രേഖകളോ ലിസ്റ്റുകൾ വെറും ഇതെരതെദ് മറ്റേതെങ്കിലും വസ്തു പോലെ ഉപയോഗിക്കാൻ കഴിയും.

പൈത്തണിലാണ് സൈക്കിൾ ഉപയോഗ ഉദാഹരണം

മൂന്ന് യൂണിറ്റ് വർദ്ധിച്ചു നമുക്ക് നമ്പറുകൾ ചില പട്ടിക; ഞങ്ങൾ ഓരോ മൂലകം വേണമെങ്കിൽ പറയട്ടെ (അതായത്. ഇ നമ്പർ). ലൂപ്പ് രീതികൾ വേണ്ടി, ലൂപ്പ് വഴി ഞങ്ങൾ അത്തരം ഒരു ചുമതല നടപ്പാക്കാൻ.

ന്റെ ( "#" പ്രതീകം ഒരു അഭിപ്രായം ശേഷം) നമുക്ക് എവിടെ ഉചിതമായ നടപടി നിവർത്തിക്കും പെട്ടെന്നുള്ള ഉദാഹരണത്തിന്, നോക്കാം:

സ്പിസൊക്_ഛിസെല് = [5, 15, 25, 35, 45, 55, 65, 75, 85, 95] # പ്രഖ്യാപിച്ചു 10 കണക്കുകൾ അടങ്ങുന്ന അറേ പൂജ്യം = 0 # സൃഷ്ടിച്ചു കൌണ്ടർ count സ്പിസൊക്_ഛിസെല് ൽ ഘടകങ്ങൾക്കും: അറേ മേൽ # ഇതെരതെ മൂലകങ്ങളുടെയും എഴുതിവെക്കുക സ്പിസൊക്_ഛിസെല് [എണ്ണം] = # 3 മൂന്ന് എണ്ണം വർദ്ധിച്ചുവരുന്ന അറേ ഘടകങ്ങൾ count = എണ്ണം +1 # സൂചിക അടുത്ത നമ്പർ പോകുക

മുകളിൽ നിർമ്മാണ ഫലം:

സ്പിസൊക്_ഛിസെല് = [8, 18, 28, 38, 48, 58, 68, 78, 88, 98]

നമ്മുടെ ഉദാഹരണത്തിൽ, നാം അറേ «സ്പിസൊക്_ഛിസെല്» മാറ്റത്തിന്റെ മൂല്യങ്ങൾ ആഘോഷിക്കാൻ വേണ്ടി വേണമെങ്കിൽ ഒരു വേരിയബിൾ എണ്ണം, ഇല്ല. വേരിയബിൾ എണ്ണം അറേ (പട്ടികയിൽ ഓരോ എണ്ണം) ഓരോ മൂലകം ഒരു സൂചിക മൂല്യം രേഖപ്പെടുത്തിയിരിക്കുന്നു. വേരിയബിൾ «ഘടകങ്ങൾ» പട്ടികയിൽ ഫലമായി മൂല്യം ബന്ധിപ്പിക്കുന്നു. ൽ ലൂപ്പ് വേണ്ടി, ഞങ്ങൾ സംഖ്യാപരമായ പട്ടികയിൽ ഓരോ വസ്തു സംസ്കരണം എങ്ങനെ നടപ്പാക്കാൻ കാണുന്നു. ലൂപ്പ് സ്മാരകശിലകൾ, സൂചിക ഉപയോഗിച്ച് ഓരോ സംഖ്യാ വസ്തു «count» നിലവിലെ ഇതെരതെദ് ഘടകം മൂന്നു തുക ചേർത്തു. അപ്പോൾ നമ്മുടെ സൂചിക «count» ഒന്നു വേണ്ടി നിർമ്മാണ പരസ്യങ്ങൾ തുടക്കം പ്രോഗ്രാം വരുമാനം നടപ്പാക്കാൻ ഒഴുക്ക് വർദ്ധിച്ചു. അങ്ങനെ, ലൂപ്പ് അത് അവസ്ഥ നൽകിയ അണിനിരന്നു ഓരോ മൂലകം, പ്രോസസ്സ് വരെ വരെ പ്രവർത്തിക്കും. ഏതെങ്കിലും ഘടകം കാണുന്നില്ലെങ്കിൽ, പക്ഷേ, സജ്ജീകരിച്ചത്, സൈക്കിൾ പൂർത്തിയായി. നാം ഒരു കാര്യം ശ്രദ്ധ ആകർഷിക്കും: നിങ്ങൾ «എണ്ണം = എണ്ണം +1" ഒരു വരി എഴുതാൻ എങ്കിൽ, വസ്തുക്കളുടെ ഒരു പറ്റം വിജയകരമായി പ്രോസസ്സ് കണ്ടാണ്, ഫലം എപ്പോഴും ആദ്യ സംഖ്യാപരമായ ഒബ്ജക്റ്റ് സൂചിക പൂജ്യം സി ചേർക്കും.

ഇപ്പോൾ ഞങ്ങൾ ലൂപ്പ് പ്രവർത്തനം തത്ത്വങ്ങൾ അതേസമയം ചിന്തിക്കു വ്യത്യാസം തിരിച്ചറിയാൻ കഴിയും (തിരിച്ചുവിളിക്കാൻ പൊസ്ത്ചൊംദിതിഒന് കൂടെ സൈക്കിൾ നിന്നു പൈത്തണിലാണ് ലോജിക്കൽ മാനദണ്ഡങ്ങളനുസരിച്ച് പുറത്തു കൊണ്ടുപോയി എന്ന് - സത്യം (സൈക്കിൾ തുടരുന്നു) അല്ലെങ്കിൽ തെറ്റായ (സൈക്കിൾ നിർത്തുന്നു)).

എങ്ങനെ വേണ്ടി ഡിസൈൻ ഉപയോഗിച്ച് പൈത്തൺ ഒരു സ്ട്രിംഗ് കൈകാര്യം?

ഓരോ പ്രോഗ്രാമിങ് ഭാഷയിലും സൈക്കിളുകള്, അവർ, ഒരേ തത്വത്തെ, ജോലി വ്യത്യാസങ്ങൾ മാത്രം സിന്റാക്സില്പിശക് ദൃശ്യമാകുന്ന. എന്നാൽ, ഭാഷയിൽ ലൂപ്പ് വേണ്ടി "പെരുമ്പാമ്പ്" ഒരു സാധാരണ ബാലിശമായ, അതിന്റെ പ്രവർത്തനം എന്ന തത്വം കൗണ്ടറിലേക്കുള്ള പരിമിതമായ കാരണം ആണ്. ഈ ഡിസൈൻ ഓരോ ഇനം പറയുന്നു. ഈ എളുപ്പത്തിൽ പിടുത്തങ്ങൾ ജോലി മാതൃക വിശദീകരണം ഇതിന്, പക്ഷേ ആദ്യം വേണ്ടി സൈക്കിൾ ഘടന കൈകാര്യം ചെയ്യട്ടെ:

വേരിയബിളിനുള്ള

ഒരു വേരിയബിൾ സൈക്കിൾ ഓപ്പറേഷൻ ഫലം ശേഖരിക്കും

പെരെമെന്നയ_൨ ൽ

«ൽ» കീ വചനം - സൈക്കിൾ «വേണ്ടി» ജോലി അത് മുൻവ്യവസ്ഥചെയ്യുന്നു. പെരെമെംനൊയ്_൨ ഞങ്ങൾ ഇതെരതെദ് ചെയ്യുന്ന മൂല്യം വലിക്കുക. വ്യക്തത, വ്യക്തതയും, കുമാറിന്റെ വേല പൈത്തണിലാണ് സ്ട്രിങ്ങുകൾ അടുക്കുന്നതിന് എങ്ങനെ ഒരു ചെറിയ ഉദാഹരണം നോക്കാം:

അക്ഷര = 'പ്രോഗ്രാമിങ്' # ഒരു വേരിയബിൾ പ്രഖ്യാപിക്കാൻ സ്ട്രിംഗ് മൂല്യം നിയോഗിക്കുകയോ അക്ഷര ൽ സ്ലൊവൊ വേണ്ടി: # തുടരും വേരിയബിൾ അക്ഷര എന്ന കോഡുകൾ യുവര് ചെയ്യുന്ന ഒരു വേരിയബിൾ സ്ലൊവൊ, സൃഷ്ടിക്കുക പ്രിന്റ് (സ്ലൊവൊ, അവസാനം = '^') # ഔട്ട്പുട്ട് സ്ലൊവൊ ഓരോ കത്ത് ശേഷം ഒരു ചിഹ്നം ചേർക്കുക - ഒരു പക്ഷി.

സ്ക്രിപ്റ്റ് ഫലം:

പി ^ പി ^, വലിയ R ^ R ^ ഒരു ^ മീറ്റർ ^ മീറ്റർ ^ ^ പി ^, വലിയ ഒരു ^ ഒരു ^ n ^ ഒപ്പം ^ ഇ

പ്രസ്താവന തുടരും

ഓപ്പറേറ്റർ പരിഗണിക്കാതെ ലൂപ്പ് ബാലൻസ് ഓഫ്, അടുത്ത ചക്രം നടപ്പാക്കാൻ പരിവർത്തന, അവസ്ഥ നൽകിയ നടപ്പിലാക്കുന്ന തുടരും. ഒപ്പം അതേസമയം - തുടരും പ്രസ്താവന രണ്ട് ചെറുപ്പം കഴിയും ഉപയോഗിക്കുക.

ഈ ഉദാഹരണം നോക്കുക:

മതിയെന്ന 'ഓരോ കത്ത് ആവർത്തിക്കുക ഒഴികെ' എന്ന എണ്ണം == 'O' എങ്കിൽ: തുടരുക പ്രിന്റ് (= count * 2, അവസാനം '')

ഫലം പിന്തുടരുന്നത്:

പ്പ്വ്വ്ത്ത്ര്രീംമ് ക്കഅജ്ഹ്ജ്ഹ്ദ്ദുഉയുയു ബ്ബുഉക്ക്വ്വുഉ ,, ക്ക്ര്ര്ംമെഎ

ഹാൻഡ്ലർ സ്ട്രിംഗ് ഒരു കത്ത് കണ്ടെത്തിയപ്പോൾ "o" എന്ന പരിപാടിയുടെ വധശിക്ഷ ഉടൻ എവിടെ അവസ്ഥ ഓരോ കത്ത് ഡ്യൂപ്ലിക്കേറ്റ് തയ്യാറായി വചനം '' തുടരും '', സൂത്രം ഫോർവേഡ് ചെയ്തു 'ഒഴികെ ഓരോ കത്ത് ആവർത്തിക്കുക.

ബ്രേക്ക് സ്റ്റേറ്റ്മെന്റ്

കീവേഡ് «ബ്രേക്ക്» സൈക്കിൾ കണ്ടീഷൻ പ്രകാരം ലഭിച്ച അതിന്റെ മുഴുവൻ, കാത്തുനിൽക്കാതെ ശല്യപ്പെടുത്തുക വയ്ക്കുന്ന സ്ഥലം ചേർത്തു. യുക്തി വ്യവസ്ഥകളും ധാരാളം പരിപാടികൾ എഴുതുമ്പോൾ ഈ ഡിസൈൻ പലപ്പോഴും ഉപയോഗിക്കുന്നു.

പ്രവൃത്തി ബ്രേക്ക് പ്രസ്താവനയുടെ ഒരു ചെറിയ ഉദാഹരണം ശ്രദ്ധിക്കുക:

മതിയെന്ന 'ഓരോ കത്ത് ആവർത്തിക്കുക ഒഴികെ' എന്ന എണ്ണം == 'O' എങ്കിൽ: ബ്രേക്ക് പ്രിന്റ് (= count * 2, അവസാനം '')

ഫലം പിന്തുടരുന്നത്:

എൻ എൻ

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

മറ്റാരെങ്കിലും മാജിക് പദം

ഏതെങ്കിലും തരത്തിലുള്ള ഒരു പരമ്പരയിൽ മറ്റെന്തെങ്കിലും ഓപ്പറേറ്റർ അപേക്ഷിക്കാം. എന്തിന് വേണ്ടി ആണ്? അവൻ ലൂപ്പ് നിന്നു ചെയ്ത ചെയ്തെന്ന ചെക്കുകൾ ഒരു ബ്രേക്ക് അല്ലെങ്കിൽ സാധാരണ രീതി എന്നാണ്. മറ്റാരെങ്കിലും നടപ്പാക്കുന്നതിൽ നിശ്ചയിച്ചിട്ടുള്ള നിയമങ്ങൾ ബ്ലോക്ക് നില സൈക്കിൾ ഔട്ട്പുട്ട് ബ്രേക്ക് ഘടന ഉപയോഗം ഇല്ലാതെ നടപ്പാക്കുകയും ചെയ്തു എന്നു മാത്രമേ തുടങ്ങും.

ഒരു ചെറിയ ഉദാഹരണം നോക്കുക:

'ഹലോ ലോകം' എന്ന മതിയെന്ന: എണ്ണം == 'ഞാൻ' എങ്കിൽ: ബ്രേക്ക് മറ്റാരെങ്കിലും: പ്രിന്റ് ( 'നിങ്ങളുടെ വാക്യത്തിലേയ്ക്കോ കത്ത് ഉണ്ട്' ഞാൻ '')

സ്ക്രിപ്റ്റിന്റെ ഔട്ട്പുട്ട്:

നിങ്ങളുടെ ശിക്ഷ കത്ത് "ഞാൻ" അല്ല

പൈത്തൺ പ്രോഗ്രാമിംഗ് ഭാഷ വിപരീത ക്രമത്തിൽ ചക്രങ്ങൾ ഉദാഹരണങ്ങൾ

പെരുമ്പാമ്പ് റിവേഴ്സ് സൈക്കിൾ നടപ്പിലാക്കുന്നത് പോലെ? കഥാപാത്രത്തിന്റെ ലൈൻ തിരിച്ചറിഞ്ഞ് റിവേഴ്സ് ക്രമത്തിൽ പ്രിന്റ് ആവശ്യമാണ് ഒരു പ്രോഗ്രാം എഴുതി എന്നു എന്തായിരിക്കും. എങ്ങനെ ഈ നടപ്പാക്കാൻ?

താഴെ ഉദാഹരണം നോക്കുക:

സ്ലൊവൊ = 'പ്രോഗ്രാമിംഗ്' നെവ്_സ്ലൊവൊ = [] ശ്രേണിയിലെ എണ്ണം (ലെൻ (ങ്ങൾ), 0, -1) എന്ന: നെവ്_സ്ലൊവൊ.അപ്പെംദ് (ങ്ങൾ [ഐ-1]) നെവ്_സ്ലൊവ്ലൊ [ 'പി', 'പി', 'ഹേ', 'ഗ്രാം', 'പി', 'ഒരു', 'മീറ്റർ', 'മീറ്റർ', 'യു', 'പി', 'ഹേ', 'ഒരു', ' ഒരു ',' എൻ ',' യു ',' ഇ '] പ്രിന്റ് (നെവ്_സ്ലൊവൊ) [ 'പി', 'പി', 'ഹേ', 'ഗ്രാം', 'പി', 'ഒരു', 'മീറ്റർ', 'മീറ്റർ', 'യു', 'പി', 'ഹേ', 'ഒരു', ' ഒരു ',' എൻ ',' യു ',' ഇ '] പ്രിന്റ് ( ''. നെവ്_സ്ലൊവൊ ചേരാൻ ())

സ്ക്രിപ്റ്റ് ഫലം:

എഇനവൊരിംമര്ഗൊര്പ്

ചേർത്തിട്ടില്ല കണ്ണിയും

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

നിങ്ങൾ പട്ടികയ്ക്കുള്ളിലെ കണ്ണി ഉപയോഗിക്കുന്നതെങ്കിൽ, പൈത്തൺ താഴെ സിന്റാക്സ് പ്രദാനം:

ചരങ്ങളുടെ ക്രമത്തിൽ വേരിയബിളിനുള്ള: ചരങ്ങളുടെ ക്രമത്തിൽ വേരിയബിളിനുള്ള ആക്ഷൻ (ങ്ങൾ) ആക്ഷൻ (ങ്ങൾ)

പട്ടികയ്ക്കുള്ളിലെ കണ്ണി പ്രത്യേക സവിശേഷതകൾ ഏത് തരത്തിലുമുള്ള സൈക്കിൾ സൈക്കിൾ ഏതെങ്കിലും തരത്തിലുള്ള ഉപയോഗിക്കാൻ കഴിയും വസ്തുത! ഇത് ഒരു സൈക്കിൾ സമയത്ത് (അല്ലെങ്കിൽ) ഒരു ചക്രം അല്ലെങ്കിൽ വീണ്ടും അതേസമയം തിരിച്ചും വേണ്ടി കഴിയുന്നതാണ് എന്നാണ്.