ഷെൽ സ്ക്രിപ്റ്റുകൾ എഴുതാനും ട്യൂൺ ചെയ്യാനും പൈത്തൺ കൺട്രോൾ ഫ്ലോയും ലൂപ്പുകളും പഠിക്കുക - ഭാഗം 2

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

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

ഈ ഉദാഹരണം, അടിസ്ഥാനമാണെങ്കിലും, സാധാരണ ബാഷ് ടൂളുകൾ ഉപയോഗിക്കുന്നതിനേക്കാൾ എളുപ്പത്തിൽ ഷെൽ സ്ക്രിപ്റ്റുകൾ എഴുതാനുള്ള പൈത്തൺ OOP-ന്റെ കഴിവുകൾ എങ്ങനെ പ്രയോജനപ്പെടുത്താം എന്ന് വ്യക്തമാക്കാൻ ഞങ്ങളെ സഹായിക്കും.

മറ്റൊരു വിധത്തിൽ പറഞ്ഞാൽ, ഞങ്ങൾ അതിൽ നിന്ന് പോകാൻ ആഗ്രഹിക്കുന്നു

# uname -snrvm

വരെ

അഥവാ

മനോഹരമായി തോന്നുന്നു, അല്ലേ? നമുക്ക് നമ്മുടെ കൈകൾ ചുരുട്ടി അത് സാധ്യമാക്കാം.

പൈത്തണിലെ നിയന്ത്രണ പ്രവാഹം

ഞങ്ങൾ നേരത്തെ പറഞ്ഞതുപോലെ, നൽകിയിരിക്കുന്ന വ്യവസ്ഥയെ ആശ്രയിച്ച് വ്യത്യസ്ത ഫലങ്ങൾ തിരഞ്ഞെടുക്കാൻ നിയന്ത്രണ പ്രവാഹം ഞങ്ങളെ അനുവദിക്കുന്നു. പൈത്തണിലെ ഏറ്റവും ലളിതമായി നടപ്പിലാക്കുന്നത് if/else ക്ലോസ് ആണ്.

അടിസ്ഥാന വാക്യഘടന ഇതാണ്:

if condition:
    # action 1
else:
    # action 2

1. നിബന്ധന ശരിയാണെന്ന് വിലയിരുത്തുമ്പോൾ, ചുവടെയുള്ള കോഡ് ബ്ലോക്ക് എക്സിക്യൂട്ട് ചെയ്യപ്പെടും (# പ്രവർത്തനം 1 പ്രതിനിധീകരിക്കുന്നു. അല്ലെങ്കിൽ, മറ്റെന്തിന് കീഴിലുള്ള കോഡ് പ്രവർത്തിക്കും.
2. ഒരു വ്യവസ്ഥ എന്നത് ശരിയോ തെറ്റോ എന്ന് വിലയിരുത്താൻ കഴിയുന്ന ഏത് പ്രസ്താവനയും ആകാം. ഉദാഹരണത്തിന്:

1 < 3 # true
firstName == "Gabriel" # true for me, false for anyone not named Gabriel

1. ആദ്യത്തെ ഉദാഹരണത്തിൽ ഒന്ന് മറ്റൊന്നിനേക്കാൾ വലുതാണോ എന്ന് നിർണ്ണയിക്കാൻ ഞങ്ങൾ രണ്ട് മൂല്യങ്ങൾ താരതമ്യം ചെയ്തു.
2. രണ്ടാമത്തെ ഉദാഹരണത്തിൽ, നിലവിലെ എക്സിക്യൂഷൻ പോയിന്റിൽ, അതിന്റെ മൂല്യം \ഗബ്രിയേൽ എന്നതിന് സമാനമാണോ എന്ന് നിർണ്ണയിക്കാൻ ഞങ്ങൾ firstName (ഒരു വേരിയബിൾ) താരതമ്യം ചെയ്തു.
3. കണ്ടീഷനും മറ്റ് പ്രസ്താവനകളും ഒരു കോളൻ (:)
എന്നിവയ്ക്ക് ശേഷം ഉണ്ടായിരിക്കണം
4. പൈത്തണിൽ ഇൻഡന്റേഷൻ പ്രധാനമാണ്. സമാന ഇൻഡന്റേഷനുള്ള ലൈനുകൾ ഒരേ കോഡ് ബ്ലോക്കിലായി കണക്കാക്കപ്പെടുന്നു.

പൈത്തണിൽ ലഭ്യമായ നിരവധി നിയന്ത്രണ ഫ്ലോ ടൂളുകളിൽ ഒന്ന് മാത്രമാണ് if/else പ്രസ്താവന എന്നത് ദയവായി ശ്രദ്ധിക്കുക. പിന്നീട് ഞങ്ങളുടെ സ്ക്രിപ്റ്റിൽ ഇത് ഉപയോഗിക്കുമെന്നതിനാൽ ഞങ്ങൾ അത് ഇവിടെ അവലോകനം ചെയ്തു. ഔദ്യോഗിക ഡോക്uസിൽ ബാക്കിയുള്ള ടൂളുകളെ കുറിച്ച് നിങ്ങൾക്ക് കൂടുതലറിയാനാകും.

പൈത്തണിലെ ലൂപ്പുകൾ

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

പൈത്തണിലെ ഏറ്റവും ലളിതമായ ലൂപ്പിനെ പ്രതിനിധീകരിക്കുന്നത് ഫോർ ലൂപ്പ്, തന്നിരിക്കുന്ന ലിസ്uറ്റിന്റെയോ സ്uട്രിംഗിന്റെയോ ഇനങ്ങളിൽ ആദ്യ ഇനത്തിൽ തുടങ്ങി അവസാനത്തേതിൽ അവസാനിക്കുന്നു.

അടിസ്ഥാന വാക്യഘടന:

for x in example:
	# do this

ഇവിടെ ഉദാഹരണം ഒരു ലിസ്റ്റ് അല്ലെങ്കിൽ ഒരു സ്ട്രിംഗ് ആകാം. മുമ്പത്തേതാണെങ്കിൽ, x എന്ന് പേരുള്ള വേരിയബിൾ ലിസ്റ്റിലെ ഓരോ ഇനത്തെയും പ്രതിനിധീകരിക്കുന്നു; രണ്ടാമത്തേത് ആണെങ്കിൽ, x സ്ട്രിംഗിലെ ഓരോ പ്രതീകത്തെയും പ്രതിനിധീകരിക്കുന്നു:

>>> rockBands = []
>>> rockBands.append("Roxette")
>>> rockBands.append("Guns N' Roses")
>>> rockBands.append("U2")
>>> for x in rockBands:
    	print(x)
or
>>> firstName = "Gabriel"
>>> for x in firstName:
    	print(x)

മുകളിലുള്ള ഉദാഹരണങ്ങളുടെ ഔട്ട്പുട്ട് ഇനിപ്പറയുന്ന ചിത്രത്തിൽ കാണിച്ചിരിക്കുന്നു:

പൈത്തൺ മൊഡ്യൂളുകൾ

വ്യക്തമായ കാരണങ്ങളാൽ, ഒരു ഫയലിൽ പൈത്തൺ നിർദ്ദേശങ്ങളുടെയും പ്രസ്താവനകളുടെയും ഒരു ശ്രേണി സംരക്ഷിക്കാൻ ഒരു മാർഗം ഉണ്ടായിരിക്കണം, അത് ആവശ്യമുള്ളപ്പോൾ അഭ്യർത്ഥിക്കാനാകും.

ഒരു മൊഡ്യൂൾ കൃത്യമായി എന്താണ്. പ്രത്യേകിച്ചും, ഒഎസ് മൊഡ്യൂൾ അടിസ്ഥാന ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തിന് ഒരു ഇന്റർഫേസ് നൽകുന്നു കൂടാതെ ഞങ്ങൾ സാധാരണയായി ചെയ്യുന്ന പല പ്രവർത്തനങ്ങളും ഒരു കമാൻഡ്-ലൈൻ പ്രോംപ്റ്റിൽ ചെയ്യാൻ ഞങ്ങളെ അനുവദിക്കുന്നു.

അതുപോലെ, ഞങ്ങൾ മുമ്പത്തെ ലേഖനത്തിൽ വിശദീകരിച്ചതുപോലെ വിളിക്കാവുന്ന നിരവധി രീതികളും സവിശേഷതകളും ഇത് ഉൾക്കൊള്ളുന്നു. എന്നിരുന്നാലും, ഇറക്കുമതി കീവേഡ് ഉപയോഗിച്ച് ഞങ്ങൾ അത് നമ്മുടെ പരിതസ്ഥിതിയിൽ ഇറക്കുമതി ചെയ്യണം (അല്ലെങ്കിൽ ഉൾപ്പെടുത്തണം):

>>> import os

നിലവിലുള്ള വർക്കിംഗ് ഡയറക്ടറി നമുക്ക് പ്രിന്റ് ചെയ്യാം:

>>> os.getcwd()

ആവശ്യമുള്ള സ്uക്രിപ്റ്റ് എഴുതാൻ ഇപ്പോൾ ഇതെല്ലാം ഒരുമിച്ച് ചേർക്കാം (മുൻ ലേഖനത്തിൽ ചർച്ച ചെയ്ത ആശയങ്ങൾക്കൊപ്പം).