ഉള്ളടക്ക പട്ടിക[മറയ്ക്കുക][കാണിക്കുക]
കഴിഞ്ഞ ട്യൂട്ടോറിയലിൽ, ലൂപ്പുകളെക്കുറിച്ചും ഒരു ബ്ലോക്ക് കോഡ് ഒന്നിലധികം തവണ എക്സിക്യൂട്ട് ചെയ്യുന്നതിനെക്കുറിച്ചും ഞങ്ങൾ പഠിച്ചു.
പൈത്തണിൽ, "ഫോർ ലൂപ്പ്", "നെസ്റ്റഡ് ലൂപ്പ്" എന്നിങ്ങനെയുള്ള മറ്റ് തരത്തിലുള്ള ലൂപ്പുകൾ നമുക്കുണ്ട്. അവ എങ്ങനെയാണ് ഉപയോഗിക്കുന്നത് എന്ന് നോക്കാം.
ലൂപ്പുകൾക്കായി
ഒരു സ്ട്രിംഗ് പോലുള്ള ഒരു ശേഖരത്തിന്റെ ഇനങ്ങളിൽ ആവർത്തിക്കാൻ ഞങ്ങൾ "ഫോർ ലൂപ്പ്" ഉപയോഗിക്കുന്നു. സ്ട്രിംഗ് പ്രതീകങ്ങളുടെ ഒരു ശ്രേണിയായതിനാൽ, ഇത് ഒരു ശേഖരം പോലെ കാണപ്പെടുന്നു. അതിനാൽ, ഒരു സ്ട്രിംഗിലെ ഓരോ പ്രതീകത്തിനും മുകളിൽ ആവർത്തിക്കാനും അത് ഉപയോഗിച്ച് എന്തെങ്കിലും ചെയ്യാനും നമുക്ക് ഫോർ ലൂപ്പ് ഉപയോഗിക്കാം.
ഇതാ ഒരു ഉദാഹരണം.
ഒരു വേരിയബിളും തുടർന്ന് ഒരു സ്ട്രിംഗും ഞങ്ങൾ "for" എന്ന് ടൈപ്പ് ചെയ്യുന്നു.
for item in 'Python':
ഇവിടെ "ഇനം" എന്നതിന്റെ അർത്ഥം പൈത്തൺ എന്ന വാക്കിന്റെ പ്രതീകങ്ങളാണ്. ലൂപ്പിന്റെ ആദ്യ ആവർത്തനത്തിൽ "ഇനം" എന്നാൽ 'P' എന്നാണ് അർത്ഥമാക്കുന്നത്, രണ്ടാമത്തെ ആവർത്തനം അർത്ഥമാക്കുന്നത് 'y' എന്നാണ്. നമുക്ക് ഇത് നടപ്പിലാക്കാം
ഈ സ്ട്രിംഗിലെ ഓരോ പ്രതീകവും ഒരു പുതിയ വരിയിൽ അച്ചടിച്ചിരിക്കുന്നത് നിങ്ങൾക്ക് കാണാം.
മറ്റൊരു ഉദാഹരണം നോക്കാം. പൈത്തണിൽ, ചതുര ബ്രാക്കറ്റുകൾ ഉപയോഗിച്ച് നമുക്ക് ലിസ്റ്റുകൾ നിർവചിക്കാം. അതുകൊണ്ട് സ്ക്വയർ ബ്രാക്കറ്റുകൾ ഉപയോഗിച്ച് ഒരു ലിസ്റ്റ് നിർവചിക്കാം.
for item in ['Shahbaz', 'Aayush', 'Jay']:
print(item)
ഇപ്പോൾ അത് മൂന്ന് പേരുകൾ വെവ്വേറെ വരികളിൽ ലിസ്റ്റ് ചെയ്യും.
ഈ ക്രമീകരണത്തിൽ നമുക്ക് നമ്പറുകളുടെ ഒരു ലിസ്റ്റ് ഉപയോഗിക്കാം. 0 മുതൽ 9 വരെയുള്ള എല്ലാ അക്കങ്ങളും ടൈപ്പുചെയ്യുന്നതിനുപകരം, കാര്യങ്ങൾ ലളിതമാക്കാൻ ഞാൻ ഫംഗ്ഷൻ "റേഞ്ച്" ഉപയോഗിക്കാൻ പോകുന്നു. അത് എങ്ങനെ ചെയ്യുന്നുവെന്ന് നോക്കാം.
for item in range(10):
print(item)
0-ൽ അല്ല തുടങ്ങാൻ നമുക്ക് പ്രോഗ്രാം ചെയ്യാം.
for item in range(5, 10):
ഇത് ടെർമിനലിൽ 5 മുതൽ 9 വരെയുള്ള നമ്പറുകൾ പ്രിന്റ് ചെയ്യും.
"റേഞ്ച്" ഫംഗ്ഷന് ഘട്ടങ്ങൾ ഇൻപുട്ടായി എടുക്കാനും കഴിയും. അതിനാൽ, ഞങ്ങൾ ഇത് ഇതുപോലെ എഴുതുകയാണെങ്കിൽ:
for item in range(5, 10, 2):
ഇത് 5, 7, 9 എന്നിവ പ്രിന്റ് ചെയ്യും, അതായത് ഓരോ ആവർത്തനത്തിനു ശേഷവും ഇത് രണ്ട് ഘട്ടങ്ങൾ മുന്നോട്ട് പോകുന്നു.
വ്യായാമം
ഇപ്പോൾ ഇതാ നിങ്ങൾക്കായി ഒരു വ്യായാമം. ഒരു ഷോപ്പിംഗ് കാർട്ടിലെ എല്ലാ ഇനങ്ങളുടെയും ആകെ വില കണക്കാക്കാൻ നിങ്ങൾ ഒരു പ്രോഗ്രാം എഴുതണമെന്ന് ഞാൻ ആഗ്രഹിക്കുന്നു. അതുകൊണ്ട് നമുക്ക് 10, 20, 30 എന്നിങ്ങനെയുള്ള വിലകളുടെ ഒരു ലിസ്റ്റ് ഉണ്ടെന്ന് പറയാം, ഞങ്ങളുടെ സാങ്കൽപ്പിക ഷോപ്പിംഗ് കാർട്ടിലെ എല്ലാ ഇനങ്ങളുടെയും ആകെ വില കണക്കാക്കാൻ നിങ്ങൾ ഒരു ഫോർ ലൂപ്പ് ഉപയോഗിക്കണമെന്ന് ഞാൻ ആഗ്രഹിക്കുന്നു.
നിങ്ങളുടെ മസ്തിഷ്കം പ്രവർത്തിപ്പിക്കുക, നിങ്ങൾക്ക് അത് ചെയ്യാൻ കഴിയുമോ എന്ന് നോക്കുക. വഞ്ചനയില്ല.
പരിഹാരം
ഇതുപോലെ വിലകൾ ലിസ്റ്റ് ചെയ്തുകൊണ്ട് നിങ്ങൾക്ക് ആരംഭിക്കാം.
prices = [10, 20, 30]
ഇപ്പോൾ മൊത്തം വിലയ്ക്ക് ഒരു വേരിയബിൾ ചേർക്കുക, അത് ആദ്യ ആവർത്തനത്തിന് 0 മുതൽ ആരംഭിക്കും.
total = 0
ഞങ്ങളുടെ ഫോർ ലൂപ്പ് ഇതാ.
for price in prices:
total = total + price
// ഇതുപോലെ ലളിതമാക്കാം total += price
print(f"Total: {total}")
നെസ്റ്റഡ് ലൂപ്പുകൾ
പൈത്തണിൽ, ഒരു നെസ്റ്റഡ് ലൂപ്പ് ഉപയോഗിക്കുന്നത് അടിസ്ഥാനപരമായി അർത്ഥമാക്കുന്നത് മറ്റൊരു ലൂപ്പിനുള്ളിൽ ഒരു ലൂപ്പ് ചേർക്കുകയാണ്, ഈ സാങ്കേതികത ഉപയോഗിച്ച് നമുക്ക് അതിശയകരമായ ചില കാര്യങ്ങൾ ചെയ്യാൻ കഴിയും. ഉദാഹരണത്തിന്, നമുക്ക് കോർഡിനേറ്റുകളുടെ ഒരു ലിസ്റ്റ് എളുപ്പത്തിൽ സൃഷ്ടിക്കാൻ കഴിയും.
ഒരു കോർഡിനേറ്റ്, നിങ്ങൾക്കറിയാവുന്നതുപോലെ, 'x', 'y' മൂല്യങ്ങളുടെ സംയോജനമാണ്. നമുക്ക് 0 ഉം 0 ഉം പറയാം. ഇപ്പോൾ നിങ്ങൾക്ക് ഇതുപോലുള്ള കോർഡിനേറ്റുകളുടെ ഒരു ലിസ്റ്റ് ജനറേറ്റ് ചെയ്യണമെന്ന് പറയാം. നമുക്ക് 0 ഉം 0 ഉം ഉണ്ട്, അപ്പോൾ നമുക്ക് 0 ഉം 1 ഉം ഉണ്ടാകും, തുടർന്ന് 0 ഉം 2 ഉം ഉണ്ടാകും.
അടുത്തതായി, നമ്മൾ 'x' മാറ്റാൻ പോകുന്നു. നമ്മൾ 'x' എന്നതിനായി 1 ഉപയോഗിക്കും, 'y' കോർഡിനേറ്റുകൾക്കായി ഞങ്ങൾ ഈ 3 മൂല്യങ്ങൾ വീണ്ടും ഉപയോഗിക്കും.
നെസ്റ്റഡ് ലൂപ്പുകൾ ഉപയോഗിച്ച് നമുക്ക് ഈ കോർഡിനേറ്റുകൾ എളുപ്പത്തിൽ സൃഷ്ടിക്കാൻ കഴിയും.
ഞാൻ നിനക്ക് കാണിച്ചു തരട്ടെ.
for x in range(4):
for y in range(3):
print(f'({x}, {y}')
നമുക്ക് ഔട്ട്പുട്ട് പരിശോധിക്കാം:
അതിനാൽ ഈ പ്രോഗ്രാം എങ്ങനെയാണ് നടപ്പിലാക്കുന്നതെന്ന് ഞാൻ കൃത്യമായി വിശദീകരിക്കാം. നമ്മുടെ ബാഹ്യ ലൂപ്പിന്റെ ആദ്യ ആവർത്തനത്തിൽ, 'x' എന്നത് 0 ആണ്. ഇപ്പോൾ നമ്മൾ ലൈൻ 2-ൽ ആണ്, ഇവിടെ നമുക്ക് ഒരു പുതിയ ലൂപ്പ് ഉണ്ട്, അതിനെ നമ്മൾ ആന്തരിക ലൂപ്പ് എന്ന് വിളിക്കുന്നു. ഈ ഇൻറർ ലൂപ്പിൽ, ആദ്യത്തെ ആവർത്തനത്തിൽ, 'y' 0 ആയിരിക്കും, അതിനാൽ 0 ഉം 0 ഉം ടെർമിനലിൽ പ്രിന്റ് ചെയ്യപ്പെടും.
ഇപ്പോൾ നിയന്ത്രണം ലൈൻ 2 അല്ലെങ്കിൽ ഞങ്ങളുടെ ആന്തരിക ലൂപ്പിലേക്ക് പോകുന്നു. ഈ രണ്ടാമത്തെ ആവർത്തനത്തിൽ, 'y' 1 ആയി സജ്ജീകരിക്കും, പക്ഷേ ഞങ്ങൾ ഇപ്പോഴും ഞങ്ങളുടെ ബാഹ്യ ലൂപ്പിന്റെ ആദ്യ ആവർത്തനത്തിലാണ്. അതിനാൽ 'x' ഇപ്പോഴും 0 ആണ്, എന്നാൽ ഇപ്പോൾ 'y' 1 ആയി വർദ്ധിപ്പിക്കുന്നു.
അതുകൊണ്ടാണ് നമ്മൾ ടെർമിനലിൽ 0 ഉം 1 ഉം കാണുന്നത്. ഞങ്ങളുടെ ആന്തരിക ലൂപ്പ് എക്സിക്യൂട്ട് ചെയ്യുന്നതുവരെ ഇത് തുടരും, തുടർന്ന് ഇന്റർപ്രെറ്റർ വീണ്ടും ബാഹ്യ ലൂപ്പിലേക്ക് പോകും, കൂടാതെ ബാഹ്യ ലൂപ്പ് പൂർത്തിയാകുന്നതുവരെ ഈ പ്രക്രിയ തുടരും.
വെല്ലുവിളി
ഇതാ നിങ്ങൾക്കായി ഒരു വ്യായാമം, എന്നാൽ ഇത് നിങ്ങൾ ഇതുവരെ ചെയ്തിട്ടുള്ള വ്യായാമങ്ങളേക്കാൾ അൽപ്പം വെല്ലുവിളി നിറഞ്ഞതാണ്.
നെസ്റ്റഡ് ലൂപ്പുകൾ ഉപയോഗിച്ച്, ഈ 'F' ആകൃതി വരയ്ക്കാൻ ഒരു കോഡ് എഴുതുക:
പരിഹാരം
numbers = [5, 2, 5, 2, 2]
for x_count in numbers:
output = ''
//ഞങ്ങൾ ഔട്ട്പുട്ട് വേരിയബിൾ ഒരു ശൂന്യമായ സ്ട്രിംഗിലേക്ക് പുനഃസജ്ജമാക്കാൻ പോകുന്നു.
for count in range(x_count):
output += 'x'
print(output)
നെസ്റ്റഡ് ലൂപ്പുകൾ ഉപയോഗിക്കാതെ ഇത് നടപ്പിലാക്കാൻ വളരെ ലളിതമായ ഒരു മാർഗമുണ്ട്. ഞാൻ അത് നിങ്ങൾക്ക് മനസിലാക്കാൻ വിടുന്നു.
അവസാനിപ്പിക്കുക
എല്ലാ പ്രഭാഷണങ്ങളിലും ചൂട് കൂടുന്നതായി നിങ്ങൾക്കും തോന്നുന്നുണ്ടോ?
എനിക്ക് തീർച്ചയായും അങ്ങനെ തോന്നുന്നു. നിങ്ങൾക്ക് മനസ്സിലാക്കാൻ വേണ്ടി ഞാൻ ഇത് വളരെ ലളിതമാക്കിയിരിക്കുന്നു.
നമ്മുടെ അടുത്ത പ്രഭാഷണത്തിൽ കാര്യങ്ങൾ കൊണ്ടുവരാം.
നിങ്ങളുടെ അഭിപ്രായങ്ങൾ രേഖപ്പെടുത്തുക