പൈത്തണിലെ ലൂപ്പിനായി

പൈത്തണിലെ ഫോർ ലൂപ്പിന് മറ്റ് പ്രോഗ്രാമിംഗ് ഭാഷകളേക്കാൾ വ്യത്യസ്തമായ ചില സവിശേഷതകൾ ഉണ്ട്. ഏറ്റവും കൂടുതൽ ഉപയോഗിക്കുന്ന ഒരു ലൂപ്പിൽ നിന്ന് പരമാവധി പ്രയോജനപ്പെടുത്താൻ ഞാൻ പഠിക്കുന്നത് ഞാൻ നിങ്ങൾക്ക് വിട്ടുതരുന്നു.

പൈത്തണിൽ, അത് ഒരു ലിസ്‌റ്റോ, ഒബ്‌ജക്‌റ്റോ അല്ലെങ്കിൽ മറ്റൊരു ഘടകമോ ആകട്ടെ, ആവർത്തിക്കാവുന്ന ഒബ്‌ജക്‌റ്റിലൂടെ ആവർത്തിക്കാൻ ഉദ്ദേശിച്ചുള്ളതാണ്.

ഇനിപ്പറയുന്ന ഘടനയാണ്

h2=[ 'Valencia', 'Castellón', 'Alicante']

for j in h2:
   instructions

ഇവിടെ h2 എന്നത് ആവർത്തിക്കാവുന്ന ഒരു ഘടകമാണ്, ഉദാഹരണത്തിന് ഒരു ലിസ്റ്റ് h2=[ 'Valencia', 'Castellón', 'Alicante']. ലൂപ്പിന് 3 ആവർത്തനങ്ങൾ ഉണ്ടാകും, ആദ്യത്തേതിൽ j=Valencia രണ്ടാമത്തേതിൽ j=Castellón എന്ന വേരിയബിൾ.

പൈത്തണിൽ അത്യാവശ്യമായതും പലരും അവഗണിക്കുന്നതുമായ ഇൻഡന്റേഷൻ എപ്പോഴും ഓർത്തുകൊണ്ടും, കോഡിൽ പിശകുകൾ വരുമ്പോഴും നമുക്ക് ആവശ്യമുള്ള നിർദ്ദേശങ്ങൾ നിർവചിക്കാം.

ലൂപ്പിനായി കൃത്യമായ എണ്ണം ആവർത്തിക്കുക.

C++-ൽ ചെയ്യാൻ കഴിയുന്നത് പോലെ ഒരു നിശ്ചിത എണ്ണം തവണ ആവർത്തിക്കണമെങ്കിൽ നമ്മൾ റേഞ്ച്() ഉപയോഗിക്കേണ്ടി വരും. 10 തവണ ആവർത്തിക്കാൻ ഞങ്ങൾ a ഉപയോഗിക്കും

for element in Range(9):
    instructions

റേഞ്ച് 9 ൽ നിന്ന് ആരംഭിക്കുന്നതിനാൽ 10 അല്ല 0 എന്ന് ഞങ്ങൾ ഇടുന്നു, അതിനാൽ 0 മുതൽ 9 വരെ ലൂപ്പിന്റെ 10 ആവർത്തനങ്ങളോ തിരിവുകളോ ഉണ്ട്.

റേഞ്ച്() അറിയുന്നത്, ഒരു നമ്പർ ഉള്ളിൽ ഇടുന്നതിനുപകരം, ഒരു വേരിയബിൾ ഇടാൻ ഞങ്ങളെ അനുവദിക്കുന്നു, അതിലൂടെ നമുക്ക് കൂടുതൽ നിയന്ത്രണം ലഭിക്കും.

var = 10
for element in Range(var):
    instructions

റേഞ്ച് ഫംഗ്‌ഷന് നിരവധി ഓപ്ഷനുകൾ ഉണ്ട്, ഞാൻ മറ്റൊരു പോസ്റ്റിൽ അതിനെക്കുറിച്ച് സംസാരിക്കും, അതിനാൽ ഉള്ളടക്കം മിക്സ് ചെയ്യാതിരിക്കാനും കഴിയുന്നത്ര വികസിപ്പിക്കാനും.

ഫോർ ലൂപ്പിന്റെ ഒഴുക്ക് നിയന്ത്രിക്കാൻ കൂടുതൽ കാര്യങ്ങൾ ചെയ്യാനാകും.

പ്രസ്താവനകൾ തകർക്കുക, തുടരുക

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

അവ മറ്റ് ലൂപ്പുകളിൽ പ്രവർത്തിക്കുന്നു, കൂടാതെ രസകരമായ മറ്റൊരു പ്രസ്താവനയുണ്ട്, അത് എക്‌സിക്യൂട്ട് ചെയ്‌തതും എന്നാൽ ഒന്നും ചെയ്യാത്തതുമായ ഒരു പ്രസ്താവനയാണ്, കമാൻഡുകൾ ആവശ്യമുള്ള ഒരു ഘടന നിർവചിക്കാൻ ഞങ്ങൾ ആഗ്രഹിക്കുമ്പോൾ അത് അനുയോജ്യമാണ്, എന്നാൽ അവ പിന്നീട് ഇടാൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നു (അഭിപ്രായങ്ങൾ ഇതിന് ഉപയോഗപ്രദമല്ല)

ബ്രേക്ക്

ബ്രേക്ക് ഉപയോഗിച്ച് നമുക്ക് എപ്പോൾ വേണമെങ്കിലും ലൂപ്പിൽ നിന്ന് പുറത്തുകടക്കാം. നിങ്ങൾ സങ്കൽപ്പിക്കുന്നതുപോലെ വളരെ ഉപയോഗപ്രദമാണ്. അതേസമയം, മറ്റ് ഘടനകൾ ഉണ്ടെന്നത് ശരിയാണ്,

numeros = [1, 2, 4, 3, 5, 8, 6]
for n in numeros:
    if n == 3:
        break
else:
    print('No se encontró el número 3')

തുടരുക

ഇത് ലൂപ്പിലെ അടുത്ത ഘടകത്തിലേക്ക് പോകാൻ ഞങ്ങളെ പ്രേരിപ്പിക്കുന്നു.

numeros = [1, 2, 4, 3, 5, 8, 6]
for n in numeros:
    if n == 3:
        continue
else:
    print('No se encontró el número 3')

https://j2logo.com/bucle-for-en-python/

വേറെ

For എന്നതിൽ നിന്ന് ഉരുത്തിരിഞ്ഞ ഒരു ഘടനയുണ്ട്, അത് വേറെ

datos = [1, 2, 3, 4, 5]
for n in datos:
    if n == 2:
        break
else:
    print('No hay 2')

ഇത് ആവശ്യമാണെന്നും പലരും ഇത് നേടുന്നതിന് ബദൽ മാർഗങ്ങൾ ഉപയോഗിക്കുന്നുണ്ടെന്നും കണ്ടതിന് ശേഷമാണ് ഈ ഘടന ഉടലെടുത്തത്. അങ്ങനെ, അവർ ആളുകളെ സഹായിക്കുകയും കൂടുതൽ വായിക്കാനാകുന്ന കോഡ് നേടുകയും ചെയ്യുന്നു

_ വേണ്ടി

ഞാൻ ഇത് ചില പ്രോഗ്രാമുകളിൽ കണ്ടിട്ടുണ്ടെങ്കിലും ഞാൻ ഇത് ഉപയോഗിച്ചിട്ടില്ല.

നമ്മൾ ഒരു ഒബ്ജക്റ്റ്, ലിസ്റ്റ്, നിഘണ്ടു മുതലായവ ആവർത്തിക്കുമ്പോൾ, എന്നാൽ ആ ഘടകങ്ങളുടെ ഉള്ളടക്കം ഞങ്ങൾക്ക് താൽപ്പര്യമില്ലാത്തതിനാൽ, നമുക്ക് അത് സൂചിപ്പിക്കാൻ കഴിയും _

ഒരു ഉദാഹരണം:

ഒരു ലിസ്‌റ്റിന്റെ ഘടകങ്ങൾ കണക്കാക്കാൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നു, പക്ഷേ അതിൽ എന്താണ് അടങ്ങിയിരിക്കുന്നതെന്ന് ഞങ്ങൾ ശ്രദ്ധിക്കുന്നില്ല, ഞങ്ങൾക്ക് അതിന്റെ ദൈർഘ്യം വേണം.

h2=[ 'Valencia', 'Castellón', 'Alicante']
count = 0
for _ in h2:
    cont += 1

പല സൈറ്റുകളിലും ഈ രീതി ദുരുപയോഗം ചെയ്യരുതെന്ന് അവർ ശുപാർശ ചെയ്യുന്നു. ഇത് അവതരിപ്പിക്കുന്ന ഗുണങ്ങൾ എനിക്ക് ശരിക്കും അറിയില്ല, ഇത് വേഗതയേറിയതാണോ?

പിന്നിലേക്ക് വളയുന്നു

ലൂപ്പിനായി പിന്നോട്ട്. അവസാനം മുതൽ തുടക്കം വരെ ആവർത്തിക്കാൻ

ഇത് പൈത്തൺ 3-ൽ അവതരിപ്പിച്ച റിവേഴ്സ്ഡ്() ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നു

h2=[ 'Valencia', 'Castellón', 'Alicante']

for j in reversed(h2):
    print (j)

രണ്ട് സൂചികകളുള്ള ലൂപ്പിംഗ്, ഇറ്ററബിൾ, ഇൻഡക്സ് എന്നിവയുടെ മൂല്യം

enumerate() ഉപയോഗിച്ച് നമുക്ക് ഒരു ശേഖരത്തിന്റെ സൂചികകളുമായി പ്രവർത്തിക്കാം. കാരണം, പലതവണ, ആവർത്തിക്കാവുന്ന വസ്തുവിന്റെ മൂല്യത്തിന് പുറമേ, അതിന്റെ സൂചികയിൽ ഞങ്ങൾക്ക് താൽപ്പര്യമുണ്ട്.

h2=[ 'Valencia', 'Castellón', 'Alicante']

for j, h in enumerate(h2):
    print j, '-->', h2[i] 

2 ലിസ്റ്റുകളിൽ കൂടുതൽ ആവർത്തിക്കുന്നു

വളരെ രസകരമായ മറ്റൊരു ഓപ്ഷൻ zip() ആണ്, അത് ഞങ്ങളുടെ ജോലി എളുപ്പമാക്കുകയും ഞങ്ങളുടെ കോഡ് ലളിതവും കൂടുതൽ വായിക്കാവുന്നതുമാക്കുകയും ചെയ്യും.

h2=[ 'Valencia', 'Castellón', 'Alicante']
cod=[100, 200, 300]

for j, h in zip(h2, cod):
    print h2, '-->', cod 

Python 2.x-ൽ izip() ഈ ഫംഗ്‌ഷൻ മെച്ചപ്പെടുത്താൻ ഉപയോഗിച്ചു, എന്നാൽ Python 3-ൽ izip എന്നത് zip() ആണ്.

അടുക്കിയ ക്രമത്തിൽ ലൂപ്പ് ചെയ്യുന്നു

വസ്തുവിന്റെ സൂചികയ്ക്ക് പകരം അതിന്റെ മൂല്യം അനുസരിച്ച് ക്രമത്തിൽ ആവർത്തിക്കുക. sorted() ഉപയോഗിക്കുന്നു

colors = ['rojo', 'amarillo', 'verde']

for color in sorted(colors):
    print color

നമുക്ക് അത് പിന്നോട്ട് ചെയ്യണമെങ്കിൽ

colors = ['rojo', 'amarillo', 'verde']

for color in sorted(colors, reverse=True):
    print color

ഇഷ്‌ടാനുസൃത അടുക്കൽ ക്രമം

colors = ['rojo', 'amarillo', 'verde']

for color in sorted(colors, key=len):
    print color

ലൂപ്പിനുള്ള സെന്റിനൽ മൂല്യം

ലൂപ്പ് അവസാനിക്കുന്നതിന് കാരണമാകുന്ന ഒരു മൂല്യമാണ് സെന്റിനൽ മൂല്യം. ഇത് സാധാരണയായി ഒരു സമയത്ത് ലൂപ്പിലാണ് അവതരിപ്പിക്കുന്നത്, എന്നാൽ ഒരു ഫോർ ഉപയോഗിച്ച് ഇത് എങ്ങനെ ഉപയോഗിക്കാമെന്ന് റെയ്മണ്ട് ഹെറ്റിംഗർ നമുക്ക് കാണിച്ചുതരുന്നു, അത് വേഗതയേറിയതാണ്

blocks = []
for block in iter(partial(f.read, 32), ''):
    blocks.append(block)
    print (block)

എന്നതിനൊപ്പം നിഘണ്ടുകളിലൂടെ സഞ്ചരിക്കുക

ബന്ധങ്ങൾ പ്രകടിപ്പിക്കുന്നതിനും ഗ്രൂപ്പുകൾ ഉണ്ടാക്കുന്നതിനും നിഘണ്ടുക്കൾ അവശ്യ ഉപകരണങ്ങളാണ്.

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

d = {'casa': 'azul', 'coche': 'rojo', 'hombre': 'verde'}

for k in d.keys():
    if k.startswith('r'):
        del d[k]

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

d.keys() ആർഗ്യുമെന്റുകളെ വിളിക്കുകയും നമുക്ക് പരിഷ്‌ക്കരിക്കാവുന്ന ഒരു ലിസ്റ്റിൽ സംഭരിക്കുന്ന ഒരു പകർപ്പ് ഉണ്ടാക്കുകയും ചെയ്യുന്നു.

പരമ്പരാഗതമായ ഒന്നിന് പകരം സൂചികകളും മൂല്യങ്ങളും നേടുക, പ്രോഗ്രാമിംഗ് ആരംഭിക്കുന്ന നമ്മളിൽ ആദ്യം മനസ്സിൽ വരുന്നത് അതാണ്

for k in d:
    print k, '-->', d[k]

ഞങ്ങൾ ഈ വളരെ വേഗത്തിലുള്ള ഓപ്ഷൻ ഉപയോഗിക്കും

for k, v in d.items():
    print k, '-->', v

ഇനങ്ങളെക്കാൾ () ഇനങ്ങൾ ()

റെയ്മണ്ട് ഹെറ്റിംഗറിന്റെ പൈത്തണിലെ ലൂപ്പുകളെ കുറിച്ച് സംസാരിക്കുക

ഇത് പഴയതും എന്നാൽ വളരെ ചിത്രീകരണാത്മകവുമായ വീഡിയോയാണ്, ആദ്യ 20 മിനിറ്റിനുള്ളിൽ റെയ്മണ്ട് ഹെറ്റിംഗർ പൈത്തണിലെ ലൂപ്പുകളുടെ വ്യത്യസ്ത സാധ്യതകൾ പഠിപ്പിക്കുകയും ലൂപ്പ് കൂടുതൽ വായിക്കാവുന്നതും ലളിതവുമാക്കുന്നതിന് ആളുകൾ വ്യാപകമായി ഉപയോഗിക്കുന്ന ഘടനകളെ ഫംഗ്‌ഷനുകളാക്കി മാറ്റുന്നതിന്റെ ഉദാഹരണങ്ങൾ നൽകുകയും ചെയ്യുന്നു. കോഡ്.

ഒരു അഭിപ്രായം ഇടൂ