പൈത്തൺ സിസ് മൊഡ്യൂൾ പഠിക്കുക

ഈ ലേഖനത്തിൽ, നമ്മൾ പൈത്തൺ സിസ് മൊഡ്യൂളിലേക്ക് നോക്കും. വ്യാഖ്യാതാവ് പരിപാലിക്കുന്ന വേരിയബിളുകളും ഫംഗ്ഷനുകളും ഉണ്ട്, അവയുമായി ഇടപഴകുന്നതിനുള്ള ഒരു മാർഗം sys മൊഡ്യൂൾ നൽകുന്നു. വ്യാഖ്യാതാവ് ജീവിച്ചിരിക്കുന്നതുവരെ ഈ വേരിയബിളുകൾ ലഭ്യമാണ്. സാധാരണയായി ഉപയോഗിക്കുന്ന ചില sys ഫംഗ്uഷനുകളിലേക്ക് നമുക്ക് ഒരു നോട്ടം ഉണ്ടാകും.

sys മൊഡ്യൂളുമായി പ്രവർത്തിക്കാൻ നിങ്ങൾ ആദ്യം മൊഡ്യൂൾ ഇറക്കുമതി ചെയ്യണം.

sys.version - പൈത്തണിന്റെ നിലവിലെ പതിപ്പിനെക്കുറിച്ചുള്ള വിവരങ്ങൾ ഇത് സംഭരിക്കുന്നു.

$ python3
>>> import sys
>>> sys.version

sys.path - പാത്ത് വേരിയബിൾ സ്ട്രിംഗുകളുടെ ഒരു ലിസ്റ്റ് രൂപത്തിൽ ഡയറക്ടറി പാത്ത് സംഭരിക്കുന്നു. നിങ്ങൾ ഒരു മൊഡ്യൂൾ ഇംപോർട്ട് ചെയ്യുമ്പോഴോ ഒരു ആപേക്ഷിക പാത്ത് ഉപയോഗിച്ച് ഒരു പ്രോഗ്രാം പ്രവർത്തിപ്പിക്കുമ്പോഴോ, പാത്ത് വേരിയബിൾ ഉപയോഗിച്ച് ആവശ്യമായ മൊഡ്യൂളിനോ സ്ക്രിപ്റ്റിനോ വേണ്ടി പൈത്തൺ ഇന്റർപ്രെറ്റർ തിരയുന്നു.

\Zero എന്ന സൂചികയിൽ പൈത്തൺ വ്യാഖ്യാതാവിനെ അഭ്യർത്ഥിക്കാൻ ഉപയോഗിച്ച സ്uക്രിപ്റ്റ് അടങ്ങുന്ന ഡയറക്uടറി പാത്ത് ഇൻഡക്uസ് സംഭരിക്കുന്നു. ഇന്റർപ്രെട്ടർ ഇന്ററാക്uറ്റീവായി അല്ലെങ്കിൽ സ്റ്റാൻഡേർഡ് ഇൻപുട്ടിൽ നിന്ന് സ്uക്രിപ്റ്റ് വായിക്കുകയാണെങ്കിൽ, പാത്ത്[0] ഒരു ശൂന്യമായ സ്uട്രിംഗ് ആയിരിക്കും.

>>> sys.path

സ്ക്രിപ്റ്റ് അഭ്യർത്ഥിക്കുമ്പോൾ പാത്ത്[0] ഡയറക്ടറി പാത്ത് സംഭരിക്കുന്നു.

$ vim 1.py
$ python3 1.py

നിങ്ങൾക്ക് ഒരു ഇഷ്uടാനുസൃത ഡയറക്uടറിയിൽ മൊഡ്യൂളുകൾ ഉണ്ടെങ്കിൽ, നിങ്ങൾക്ക് path.append() രീതി ഉപയോഗിച്ച് പാത്ത് വേരിയബിളിലേക്ക് ഡയറക്uടറി പാത്ത് ചേർക്കാൻ കഴിയും (പാത്ത് ഒരു ലിസ്റ്റ് ഒബ്uജക്റ്റ് ആയതിനാൽ ഞങ്ങൾ ലിസ്റ്റ് രീതി \append ഉപയോഗിക്കുന്നു).

$ python3
>>> import sys
>>> sys.path
>>> sys.path.append('/root/test/')
>>> sys.path

sys.argv - നിങ്ങളുടെ പൈത്തൺ പ്രോഗ്രാമിലേക്ക് റൺ ടൈം ആർഗ്യുമെന്റുകൾ കൈമാറാൻ argv ഉപയോഗിക്കുന്നു. Argv എന്നത് സ്uക്രിപ്റ്റ് നാമത്തെ ഒന്നാം മൂല്യമായി സംഭരിക്കുന്ന ഒരു ലിസ്uറ്റാണ്, തുടർന്ന് ഞങ്ങൾ പാസാക്കുന്ന ആർഗ്യുമെന്റുകൾ. Argv മൂല്യങ്ങൾ ടൈപ്പ് സ്ട്രിംഗായി സംഭരിച്ചിരിക്കുന്നു, നിങ്ങളുടെ ആവശ്യങ്ങൾക്കനുസരിച്ച് അത് വ്യക്തമായി പരിവർത്തനം ചെയ്യണം.

>>> sys.argv

നിങ്ങൾ സ്uനിപ്പെറ്റിന് താഴെ റൺ ചെയ്യുമ്പോൾ, റേഞ്ച് ഫംഗ്uഷന്റെ അവസാന മൂല്യം sys.argv[1] വഴി 10 ആയി കൈമാറുകയും പ്രോഗ്രാമിന്റെ അവസാനത്തിൽ argv മൂല്യങ്ങളുടെ ലിസ്റ്റ് പ്രിന്റ് ചെയ്യുന്നതിനായി മറ്റ് ചില മൂല്യങ്ങളും കൈമാറുകയും ചെയ്യുന്നു.

#!/usr/bin/python3

import sys

for x in range(1,int(sys.argv[1])):
    print(x)
    
# Print all the arguments passed
print("Arguments passed:",sys.argv)

sys.executable - പൈത്തൺ ഇന്റർപ്രെറ്റർ ബൈനറിയുടെ കേവല പാത പ്രിന്റ് ചെയ്യുന്നു.

>>> sys.executable
'/usr/bin/python3'

sys.platform - OS പ്ലാറ്റ്ഫോം തരം പ്രിന്റ് ചെയ്യുന്നു. നിങ്ങളുടെ പ്രോഗ്രാം ഒരു പ്ലാറ്റ്ഫോം ആശ്രിതമായി പ്രവർത്തിപ്പിക്കുമ്പോൾ ഈ പ്രവർത്തനം വളരെ ഉപയോഗപ്രദമാകും.

>>> sys.platform
'linux'

sys.exit – SystemExit(status) ഉയർത്തി ഇന്റർപ്രെറ്ററിൽ നിന്ന് പുറത്തുകടക്കുക. സ്ഥിരസ്ഥിതിയായി, സ്റ്റാറ്റസ് സീറോ ആണെന്ന് പറയുകയും വിജയകരമാണെന്ന് പറയുകയും ചെയ്യുന്നു. നമുക്ക് ഒന്നുകിൽ എക്സിറ്റ് സ്റ്റാറ്റസായി ഒരു പൂർണ്ണസംഖ്യ മൂല്യം ഉപയോഗിക്കാം അല്ലെങ്കിൽ ചുവടെയുള്ള ഉദാഹരണത്തിൽ കാണിച്ചിരിക്കുന്നതുപോലെ സ്ട്രിംഗ് (\പരാജയപ്പെട്ടു) പോലുള്ള മറ്റ് തരത്തിലുള്ള ഒബ്uജക്റ്റുകൾ ഉപയോഗിക്കാം.

സാമ്പിളിന് താഴെ, പ്ലാറ്റ്uഫോം വിൻഡോകളാണോ എന്ന് പരിശോധിക്കാൻ ഒരു സ്uനിപ്പറ്റ് ഉപയോഗിക്കുന്നു, തുടർന്ന് കോഡ് പ്രവർത്തിപ്പിക്കുക. ഇല്ലെങ്കിൽ എക്സിറ്റ്() ഫംഗ്uഷൻ ഉയർത്തുക.

#!/usr/bin/python3

import sys

if sys.platform == 'windows':  # CHECK ENVIRONMENT
    #code goes here
    pass
else:
    print("This script is intended to run only on Windows, Detected platform: ", sys.platform)
    sys.exit("Failed")

sys.maxsize - ഇത് ഒരു വേരിയബിളിന് കൈവശം വയ്ക്കാൻ കഴിയുന്ന പരമാവധി മൂല്യത്തെ പ്രതിനിധീകരിക്കുന്ന ഒരു പൂർണ്ണസംഖ്യയാണ്.

On a 32-bit platform it is 2**31 - 1 
On a 64-bit platform it is 2**63 - 1

sys മൊഡ്യൂളിന്റെ ചില പ്രധാന ഫംഗ്uഷനുകൾ ഞങ്ങൾ കണ്ടു, കൂടാതെ ധാരാളം ഫംഗ്uഷനുകളും ഉണ്ട്. ഞങ്ങൾ അടുത്ത ലേഖനവുമായി വരുന്നത് വരെ നിങ്ങൾക്ക് sys മൊഡ്യൂളിനെക്കുറിച്ച് കൂടുതൽ ഇവിടെ വായിക്കാം.