ഉള്ളടക്ക പട്ടിക[മറയ്ക്കുക][കാണിക്കുക]
ഈ പ്രഭാഷണം പൈത്തണിലെ മൊഡ്യൂളുകളിലേക്കും പാക്കേജുകളിലേക്കും വ്യാപിക്കും.
ഫയലുകളുടെ രൂപത്തിൽ നിങ്ങളുടെ കോഡ് ഓർഗനൈസുചെയ്യാനുള്ള ഒരു മാർഗമാണ് അവ, പൈത്തൺ ഉപയോഗിച്ച് വെബ് ആപ്ലിക്കേഷനുകൾ നിർമ്മിക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നുവെങ്കിൽ അത് വളരെ പ്രധാനമാണ്.
മൊഡ്യൂളുകൾ
പൈത്തണിലെ ഒരു മൊഡ്യൂൾ അടിസ്ഥാനപരമായി ചില പൈത്തൺ കോഡുള്ള ഒരു ഫയലാണ്, അത് നമ്മുടെ കോഡ് ഫയലുകളായി ക്രമീകരിക്കാൻ ഉപയോഗിക്കുന്നു. ഒരു സൂപ്പർമാർക്കറ്റിലെ വിഭാഗങ്ങൾ പോലെ ചിന്തിക്കുക. നിങ്ങൾ ഒരു സൂപ്പർമാർക്കറ്റിൽ പോകുമ്പോൾ പഴങ്ങൾ, പച്ചക്കറികൾ, ക്ലീനിംഗ് ഉൽപന്നങ്ങൾ തുടങ്ങി വിവിധ വിഭാഗങ്ങളുണ്ട്. എല്ലാ ഉൽപ്പന്നങ്ങളും ഉള്ള ഒരു വിഭാഗം നിങ്ങൾ കാണില്ല.
പ്രോഗ്രാമിംഗിലും ഇതേ ആശയമാണ്. main.py-യിൽ എല്ലാ ഫംഗ്ഷനുകളും ക്ലാസുകളും ഉപയോഗിച്ച് ഞങ്ങളുടെ എല്ലാ കോഡും എഴുതുന്നതിനുപകരം, ഞങ്ങൾ ഞങ്ങളുടെ കോഡ് ഒന്നിലധികം ഫയലുകളായി വിഭജിക്കുന്നു. ഓരോ ഫയലും ഒരു മൊഡ്യൂൾ എന്ന് വിളിക്കുന്നു. ഇതുപയോഗിച്ച്, ഞങ്ങളുടെ കോഡ് മികച്ച രീതിയിൽ സംഘടിപ്പിക്കുകയും ഘടനാപരമായിരിക്കുകയും ചെയ്യുക മാത്രമല്ല, ഞങ്ങളുടെ കോഡ് വീണ്ടും ഉപയോഗിക്കാനുള്ള കഴിവും ഞങ്ങൾക്കുണ്ട്. അത് ഒരു ഉദാഹരണത്തിലൂടെ നോക്കാം.
ഭാരം പൗണ്ടിൽ നിന്ന് കിലോഗ്രാമിലേക്കും തിരിച്ചും പരിവർത്തനം ചെയ്യുന്നതിനുള്ള രണ്ട് പ്രവർത്തനങ്ങൾ നമുക്ക് നിർവചിക്കാം.
def lbs_to_kg(weight):
return weight * 0.45
def kg_to_lbs(weight):
return weight / 0.45
ഇപ്പോൾ, നമുക്ക് ഈ രണ്ട് ഫംഗ്ഷനുകളും എടുത്ത് അവയെ "കൺവെർട്ടറുകൾ" എന്ന് വിളിക്കുന്ന ഒരു പ്രത്യേക മൊഡ്യൂളിൽ ഇടാം, തുടർന്ന് ഈ കൺവെർട്ടർ ഫംഗ്ഷനുകൾ ആവശ്യമുള്ള ഏത് പ്രോഗ്രാമിലേക്കും അത് ഇറക്കുമതി ചെയ്യാൻ കഴിയും. ഇത് എങ്ങനെ ചെയ്യാമെന്ന് ഞാൻ കാണിച്ചുതരാം.
നമുക്ക് നമ്മുടെ പ്രോജക്റ്റ് പാനൽ തുറന്ന് പ്രോജക്റ്റിൽ റൈറ്റ് ക്ലിക്ക് ചെയ്ത് ഒരു പുതിയ ഫയൽ ചേർക്കാം. ഞങ്ങൾ ഈ ഫയലിനെ "Converters.py" എന്ന് വിളിക്കാൻ പോകുന്നു.
ഇപ്പോൾ ഡിഫോൾട്ട് ഫയലിൽ നിന്ന് കോഡ് പകർത്തി "Converters.py" എന്നതിൽ ഒട്ടിക്കുക.
ഇതുപയോഗിച്ച്, ഞങ്ങൾ ഞങ്ങളുടെ പ്രധാന മൊഡ്യൂൾ വൃത്തിയാക്കി, വ്യത്യസ്ത ഫംഗ്ഷനുകളാൽ അത് വീർക്കുന്നതല്ല. ക്ലാസുകൾക്കൊപ്പം കൂടുതൽ ഫംഗ്ഷനുകൾ എഴുതുമ്പോൾ, ഞങ്ങൾ അവയെ അവയുടെ അനുബന്ധ മൊഡ്യൂളുകളിൽ ഇടുന്നു. ഒരു മൊഡ്യൂളിൽ ബന്ധപ്പെട്ട എല്ലാ പ്രവർത്തനങ്ങളും ക്ലാസുകളും അടങ്ങിയിരിക്കണം. ഇപ്പോൾ, ഞങ്ങളുടെ ആപ്പ് മൊഡ്യൂളിലേക്ക് കൺവെർട്ടർ മൊഡ്യൂൾ ഇറക്കുമതി ചെയ്യാൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നു. ഇത് ചെയ്യുന്നതിന്, എഴുതുക import converters
".py" എന്ന വിപുലീകരണമില്ലാതെ മുകളിൽ.
രീതികൾക്ക് സമാനമായ ഒരു ഡോട്ട് ഓപ്പറേറ്റർ ഉപയോഗിച്ച് നമുക്ക് ഒരു മൊഡ്യൂളിലെ അംഗങ്ങളെ ആക്സസ് ചെയ്യാൻ കഴിയും.
നമുക്ക് 70 കിലോ പൗണ്ടാക്കി മാറ്റാം:
മൊഡ്യൂളുകൾ ഇറക്കുമതി ചെയ്യുന്നതിന് മറ്റൊരു വാക്യഘടനയും ഉണ്ട്. മൊഡ്യൂൾ മുഴുവനും ഇറക്കുമതി ചെയ്യുന്നതിനുപകരം, ആ മൊഡ്യൂളിൽ നിന്ന് നമുക്ക് നിർദ്ദിഷ്ട ഫംഗ്ഷനുകൾ ഇറക്കുമതി ചെയ്യാൻ കഴിയും. നമുക്ക് ടൈപ്പ് ചെയ്യാം from Converters import
ലഭ്യമായ ഫംഗ്ഷനുകളുടെ ലിസ്റ്റ് കാണിക്കാൻ “control + space” അമർത്തുക. ഇത് ഉപയോഗിച്ച്, നമുക്ക് ഈ ഫംഗ്ഷൻ നേരിട്ട് വിളിക്കാം.
വ്യായാമം
ഇതാ നിങ്ങളുടെ വ്യായാമം.
ഞങ്ങൾ ചർച്ച ചെയ്ത പ്രഭാഷണത്തിൽ നിന്നുള്ള ഒരു വ്യായാമവുമായി ഇത് ബന്ധപ്പെട്ടിരിക്കുന്നു.ലൂപ്പുകൾക്ക്” ഒരു ലിസ്റ്റിൽ നിന്ന് ഏറ്റവും വലിയ സംഖ്യ കണ്ടെത്താൻ ഞങ്ങൾ ഒരു പ്രോഗ്രാം എഴുതി
numbers = [8, 3, 6, 10, 5]
max = numbers[0]
for number in numbers:
if number > max:
max = number
print(max)
ഈ കോഡിന് നിലവിൽ സ്ഥാപനമില്ല. ഞങ്ങൾക്ക് ഫംഗ്ഷനുകളോ മൊഡ്യൂളുകളോ ഇല്ല, പ്രോഗ്രാം ഒരൊറ്റ ഫയലിലാണ് എഴുതിയിരിക്കുന്നത്. ചെറിയ പ്രോഗ്രാമുകൾക്ക് അത് കുഴപ്പമില്ല, എന്നാൽ നിങ്ങളുടെ പ്രോഗ്രാമുകൾ വളരുമ്പോൾ, നിങ്ങളുടെ കോഡ് ക്ലാസുകളിലേക്കും മൊഡ്യൂളുകളിലേക്കും ശരിയായി ക്രമീകരിക്കേണ്ടതുണ്ട്. അതിനാൽ, ഈ വ്യായാമത്തിന്റെ ഭാഗമായി, നിങ്ങൾ ഒരു ഫംഗ്ഷൻ എഴുതാൻ ഞാൻ ആഗ്രഹിക്കുന്നു, അതിനെ വിളിക്കുക find_max
. ഈ ഫംഗ്ഷൻ ഒരു ലിസ്റ്റ് എടുത്ത് ആ ലിസ്റ്റിലെ ഏറ്റവും വലിയ സംഖ്യ തിരികെ നൽകണം. അതിനുശേഷം മുന്നോട്ട് പോയി ഈ ഫംഗ്ഷൻ ഒരു പ്രത്യേക മൊഡ്യൂളിൽ ഇടുക, അത് ഇവിടെ നിന്ന് എക്സ്ട്രാക്റ്റ് ചെയ്ത് ഒരു മൊഡ്യൂളിൽ ഇടുക utils
. ഈ മൊഡ്യൂളിൽ ഒരു കൂട്ടം യൂട്ടിലിറ്റി ഫംഗ്ഷനുകൾ അടങ്ങിയിരിക്കണം. ഇറക്കുമതി ചെയ്യുക utils
നിലവിലെ മൊഡ്യൂളിലേക്ക് മൊഡ്യൂൾ ചെയ്ത് വിളിക്കുക find_max
പ്രവർത്തനം. അവസാനം, ഫലം നേടുകയും ടെർമിനലിൽ പ്രിന്റ് ചെയ്യുകയും ചെയ്യുക.
ഈ വ്യായാമം അൽപ്പം വെല്ലുവിളി നിറഞ്ഞതാണ്, എന്നാൽ എളുപ്പത്തിൽ ചെയ്യാൻ കഴിയും.
പരിഹാരം
ഒരു ഫംഗ്ഷൻ നിർവചിച്ചുകൊണ്ട് ആരംഭിക്കുക find_max
കൂടാതെ നമ്പറുകൾ എന്ന ഒരു പരാമീറ്റർ ചേർക്കുക. ഈ ഫംഗ്ഷനുള്ളിൽ, ഒരു ലിസ്റ്റിലെ ഏറ്റവും വലിയ സംഖ്യ കണ്ടെത്തുന്നതിനുള്ള അൽഗോരിതം എഴുതുക.
def find_max(numbers):
max = numbers[0]
for number in numbers:
if number > max:
max = number
return max
ഈ കോഡ് "utils.py" എന്ന ഫയലിൽ ഒരു മൊഡ്യൂളായി സംരക്ഷിക്കുക.
ഞങ്ങളുടെ പ്രധാന പ്രോഗ്രാമിലേക്ക് മടങ്ങുക, രണ്ടിലേതെങ്കിലും വാക്യഘടന ഉപയോഗിച്ച് മൊഡ്യൂൾ ഇമ്പോർട്ടുചെയ്ത് ലോജിക് എക്സിക്യൂട്ട് ചെയ്യുക.
ഒരു കാര്യം, ഞാൻ നിങ്ങളുടെ ശ്രദ്ധയിൽപ്പെടുത്തേണ്ടത് ദുർബലമായവയാണ് max
. അതിനുള്ള കാരണം max
പൈത്തണിലെ ഒരു ബിൽറ്റ്-ഇൻ ഫംഗ്ഷൻ ആണ്, ഞങ്ങൾ അത് പുനർനിർവചിക്കുകയാണ്. അതിനാൽ ഇത് ഒരു മുന്നറിയിപ്പാണ് പൈത്തൺ കമ്പൈലർ അതിന്റെ ബിൽറ്റ്-ഇൻ ഫംഗ്ഷനായി നമുക്ക് ഇനി max ഉപയോഗിക്കാനാവില്ല.
പൈത്തണിലെ ബിൽറ്റ്-ഇൻ മൊഡ്യൂളുകൾ
ഇമെയിലുകൾ അയയ്ക്കുക, തീയതിയും സമയവും ഉപയോഗിച്ച് പ്രവർത്തിക്കുക, ക്രമരഹിതമായ മൂല്യങ്ങളും പാസ്വേഡുകളും സൃഷ്ടിക്കുക തുടങ്ങിയ പൊതുവായ ജോലികൾക്കായി നിരവധി മൊഡ്യൂളുകൾ അടങ്ങുന്ന ഒരു സാധാരണ ലൈബ്രറിയുമായാണ് പൈത്തൺ വരുന്നത്. പൈത്തണിൽ ഇതിനകം തന്നെ നിരവധി മൊഡ്യൂളുകൾ നിർമ്മിച്ചിട്ടുണ്ട്, അതിനർത്ഥം നമുക്ക് വീണ്ടും ഉപയോഗിക്കാനാകുന്ന നിരവധി പ്രവർത്തനങ്ങൾ ഇതിനകം തന്നെ ഉണ്ട്. നിങ്ങൾക്ക് ഈ മൊഡ്യൂളുകൾ കണ്ടെത്താം ഇവിടെ.
പാക്കേജുകൾ
മൊഡ്യൂളുകൾക്ക് മുകളിൽ ഞങ്ങളുടെ കോഡ് ക്രമീകരിക്കുന്നതിനുള്ള മറ്റൊരു മാർഗമാണ് പാക്കേജുകൾ. ഒരു യഥാർത്ഥ പ്രോജക്റ്റിൽ നൂറുകണക്കിന് അല്ലെങ്കിൽ ആയിരക്കണക്കിന് മൊഡ്യൂളുകൾ അടങ്ങിയിരിക്കാം, കാലക്രമേണ ഞങ്ങളുടെ ഡയറക്ടറി നിരവധി ഫയലുകൾ കൊണ്ട് വീർപ്പുമുട്ടും. അതിനാൽ, ഒരു പാക്കേജിനുള്ളിൽ അനുബന്ധ മൊഡ്യൂളുകൾ ക്രമീകരിക്കുക എന്നതാണ് ഒരു മികച്ച സമീപനം, അത് പാക്കേജിനെ ഒന്നിലധികം മൊഡ്യൂളുകൾക്കുള്ള ഒരു കണ്ടെയ്നറാക്കി മാറ്റുന്നു.
പ്രോജക്റ്റിലേക്ക് ഒരു പുതിയ ഡയറക്ടറി ചേർക്കുകയും ബന്ധപ്പെട്ട എല്ലാ മൊഡ്യൂളുകളും ആ ഡയറക്ടറിയിലേക്ക് ചേർക്കുകയും ചെയ്യുന്നു. ഉദാഹരണമായി, ഒരു മാളിനെക്കുറിച്ച് ചിന്തിക്കുക. പാക്കേജുകൾ പോലെയുള്ള ഒരു മാളിൽ പുരുഷന്മാർക്കും സ്ത്രീകൾക്കും കുട്ടികൾക്കുമുള്ള വിവിധ വിഭാഗങ്ങളുണ്ട്. ഷൂസ്, ടീ-ഷർട്ടുകൾ, ജാക്കറ്റുകൾ എന്നിങ്ങനെ വ്യത്യസ്ത തരത്തിലുള്ള ഉൽപ്പന്നങ്ങൾക്ക് ഓരോ വിഭാഗത്തിനും വ്യത്യസ്ത മേഖലകളുണ്ട്. ഇവ മൊഡ്യൂളുകളായി കരുതുക.
പൈത്തണിൽ പാക്കേജുകൾ എങ്ങനെ സൃഷ്ടിക്കാമെന്നും ഉപയോഗിക്കാമെന്നും നോക്കാം.
ആദ്യം, പ്രോജക്റ്റ് പാനലിൽ നിന്ന് ഒരു പുതിയ ഡയറക്ടറി ചേർക്കുക. നമുക്ക് അതിനെ "ഇകൊമേഴ്സ്" എന്ന് വിളിക്കാം. ഈ പാക്കേജിൽ ഒരു ഇ-കൊമേഴ്സ് ആപ്ലിക്കേഷനുമായി ബന്ധപ്പെട്ട എല്ലാ മൊഡ്യൂളുകളും അടങ്ങിയിരിക്കും.
ഇത് ഇപ്പോഴും ഒരു ശൂന്യമായ ഡയറക്ടറിയാണ്, അതിനെ ഒരു പാക്കേജാക്കി മാറ്റുന്നതിന്, അതിൽ ഒരു പ്രത്യേക ഫയൽ സൃഷ്ടിക്കേണ്ടതുണ്ട്. ഈ ഡയറക്ടറിയിൽ ഒരു പുതിയ പൈത്തൺ ഫയൽ ചേർക്കുകയും ആ ഫയലിന് “__init__” എന്ന് പേരിടുകയും ചെയ്യുക. ഇത് പൈത്തണിലെ ഒരു പ്രത്യേക കൺവെൻഷനാണ്, പൈത്തൺ ഇന്റർപ്രെറ്റർ ഈ പേരുള്ള ഒരു ഫയൽ ഒരു ഡയറക്ടറിയിൽ കാണുമ്പോൾ, അത് ഈ ഡയറക്ടറിയെ ഒരു പാക്കേജായി കണക്കാക്കുന്നു.
ഒരു പാക്കേജ് സൃഷ്ടിക്കുന്നതിന് ഞങ്ങൾക്ക് ഇതരവും സംക്ഷിപ്തവുമായ ഒരു രീതിയും ഉണ്ട്. പ്രോജക്റ്റ് പാനലിൽ വലത്-ക്ലിക്കുചെയ്ത് ലിസ്റ്റിൽ നിന്ന് ഒരു പൈത്തൺ പാക്കേജ് സൃഷ്ടിക്കുക. "ഇ-കൊമേഴ്സ്" എന്ന് പേര് നൽകുക, അത്രമാത്രം. “__init__” എന്ന പേരിലുള്ള പൈത്തൺ ഫയലുള്ള ഒരു ഡയറക്ടറി ഇത് സ്വയമേവ സൃഷ്ടിക്കും.
ഇപ്പോൾ, പാക്കേജിൽ ഒരു മൊഡ്യൂൾ സൃഷ്ടിച്ച് അതിന് “ഷിപ്പിംഗ്” എന്ന് പേരിടാം. ഈ മൊഡ്യൂളിൽ, ഷിപ്പിംഗ് ചെലവുകൾ കണക്കാക്കുന്നതിനുള്ള ഒരു ലളിതമായ ഫംഗ്ഷൻ സൃഷ്ടിക്കാം.
def calc_shipping():
print("calc_shipping")
ഞങ്ങളുടെ പ്രധാന മൊഡ്യൂളിൽ ഈ ഫംഗ്ഷൻ ആക്സസ് ചെയ്യുന്നതിന്, ഞങ്ങൾ അത് ഇ-കൊമേഴ്സ് പാക്കേജ് വഴി ആക്സസ് ചെയ്യണം. ഈ മൊഡ്യൂൾ ഇമ്പോർട്ടുചെയ്യാൻ ഞങ്ങൾക്ക് വീണ്ടും രണ്ട് രീതികളുണ്ട്.
ആദ്യ രീതിയിൽ, നമുക്ക് മുഴുവൻ മൊഡ്യൂളും ഇമ്പോർട്ടുചെയ്യാം, തുടർന്ന് ഇതുപോലെ സ്വതന്ത്രമായി ഒരു ഫംഗ്ഷൻ വിളിക്കാം:
import eCommerce.shipping
eCommerce.shipping.calc_shipping()
എന്നിരുന്നാലും, ഈ സമീപനത്തിലൂടെ, ഈ മൊഡ്യൂളിലേക്ക് ഫംഗ്ഷനുകളിലൊന്ന് വിളിക്കുന്നതിന് അത് പ്രിഫിക്സ് ചെയ്യേണ്ടതുണ്ട് eCommerce.shipping.
അത് വളരെ വാചാലമാണ്. അതിനാൽ, പാക്കേജുകളിൽ പ്രവർത്തിക്കുമ്പോൾ ഞങ്ങൾ പലപ്പോഴും രണ്ടാമത്തെ സമീപനം ഉപയോഗിക്കുകയും ഉപയോഗിക്കുകയും ചെയ്യുന്നു from
പ്രസ്താവന.
from eCommerce.shipping import calc_shipping
calc_shipping()
നിങ്ങൾക്ക് ഒരു മൊഡ്യൂളിൽ ഒന്നിലധികം ഫംഗ്ഷനുകൾ ഉണ്ടെങ്കിൽ അവയ്ക്കിടയിൽ കോമകൾ ഉപയോഗിച്ച് അവയെല്ലാം ഒറ്റ വരിയിൽ ഇമ്പോർട്ടുചെയ്യാനാകും. നമ്മുടെ ഷിപ്പിംഗ് മൊഡ്യൂളിൽ നികുതി കണക്കാക്കുന്നതിനുള്ള മറ്റൊരു ഫംഗ്ഷൻ ഉണ്ടെന്ന് പറയാം. അത് ഇതുപോലെ ഇറക്കുമതി ചെയ്യും:
from eCommerce.shipping import calc_shipping, calc_tax
നിങ്ങൾക്ക് വ്യക്തിഗത മൊഡ്യൂളുകൾ ഇമ്പോർട്ടുചെയ്യാനും പ്രോഗ്രാമിൽ പിന്നീടുള്ള ഘട്ടത്തിൽ ഫംഗ്ഷനുകൾ നൽകാനും കഴിയും. നമുക്ക് മൊഡ്യൂൾ ഷിപ്പിംഗ് ഇറക്കുമതി ചെയ്യാം, തുടർന്ന് ഫംഗ്ഷനെ വിളിക്കാൻ ഒരു ഡോട്ട് ഓപ്പറേറ്റർ ഉപയോഗിക്കാം calc_shipping.
from eCommerce import shipping
shipping.calc_shipping()
അവസാനിപ്പിക്കുക!
പൈത്തണിൽ പാക്കേജുകളും മൊഡ്യൂളുകളും വളരെ പ്രധാനമാണ്. പ്രത്യേകിച്ചും, നിർമ്മാണത്തിനായി ഉപയോഗിക്കുന്ന ജാങ്കോ പോലുള്ള ഒരു ചട്ടക്കൂടിനൊപ്പം പ്രവർത്തിക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുമ്പോൾ വെബ് അപ്ലിക്കേഷനുകൾ പൈത്തണിനൊപ്പം. മറ്റൊരു പൈത്തൺ കോഴ്സിൽ ഞങ്ങൾ ജാങ്കോയിലേക്ക് നോക്കും.
ഈ പരമ്പരയിലെ അവസാനത്തെ പരമ്പരാഗത പ്രഭാഷണമായിരുന്നു ഇത്. അടുത്ത പ്രഭാഷണം ഞങ്ങളുടെ സാധാരണ ഫോർമാറ്റിൽ നിന്ന് വ്യതിചലിക്കുകയും പൈത്തണിലെ ചില പ്രധാന ഉപയോഗ കേസുകൾ പഠിക്കുകയും ചെയ്യും. അത് ഈ പരമ്പരയുടെ അവസാനത്തെ അടയാളപ്പെടുത്തുകയും ഞങ്ങൾ ഞങ്ങളുടെ അടുത്ത പൈത്തൺ സീരീസിലേക്ക് പോകുകയും ചെയ്യും. അതിനായി കാത്തിരിക്കുക.
നിങ്ങളുടെ അഭിപ്രായങ്ങൾ രേഖപ്പെടുത്തുക