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

തുടക്കക്കാർക്കുള്ള പൈത്തൺ. ആദ്യ അധ്യായം. "നമ്മൾ എന്തിനെക്കുറിച്ചാണ് സംസാരിക്കുന്നത്"

വെറുതെ, അല്പം വിരസമായ "സുവിശേഷീകരണം". നിങ്ങൾക്ക് അവനെ മടുത്തുവെങ്കിൽ, നിങ്ങൾക്ക് കുറച്ച് ഖണ്ഡികകൾ ഒഴിവാക്കാം.
തുടക്കക്കാർക്ക് പഠിക്കാൻ എളുപ്പമുള്ള ഒരു ലളിതമായ ഭാഷയായി ഗൈഡോ വാൻ റോസ്സം വികസിപ്പിച്ചെടുത്ത ഒരു സ്ക്രിപ്റ്റിംഗ് ഭാഷയാണ് പൈത്തൺ ("പൈത്തൺ" എന്നതിനേക്കാൾ "പൈത്തൺ" എന്ന് ഉച്ചരിക്കുന്നു).
ഇക്കാലത്ത്, പൈത്തൺ പല മേഖലകളിലും ഉപയോഗിക്കുന്ന ഒരു പരക്കെ ഉപയോഗിക്കുന്ന ഭാഷയാണ്:
- ആപ്ലിക്കേഷൻ സോഫ്റ്റ്‌വെയർ വികസനം (ഉദാഹരണത്തിന്, Linux utilities yum, pirut, system-config-*, Gajim IM ക്ലയൻ്റ് കൂടാതെ മറ്റു പലതും)
- വെബ് ആപ്ലിക്കേഷനുകളുടെ വികസനം (അതിൻ്റെ അടിസ്ഥാനത്തിൽ വികസിപ്പിച്ച ഏറ്റവും ശക്തമായ ആപ്ലിക്കേഷൻ സെർവർ സോപ്പും CMS പ്ലോണും, ഉദാഹരണത്തിന്, CIA വെബ്സൈറ്റ് പ്രവർത്തിക്കുന്നു, കൂടാതെ ദ്രുത ആപ്ലിക്കേഷൻ ഡെവലപ്‌മെൻ്റിനായി ധാരാളം ചട്ടക്കൂടുകൾ, Django, TurboGears എന്നിവയും മറ്റു പലതും)
- മാത്രമല്ല (OpenOffice.org ഓഫീസ് സ്യൂട്ടിൽ, Blender 3d എഡിറ്റർ, Postgre DBMS ൽ) മാത്രമല്ല, പല ഗെയിമുകളിലും ഉൾച്ചേർത്ത സ്ക്രിപ്റ്റിംഗ് ഭാഷയായി ഉപയോഗിക്കുക
- ശാസ്ത്രീയ കണക്കുകൂട്ടലുകളിൽ ഉപയോഗിക്കുക (കണക്കുകൂട്ടലുകൾക്കുള്ള SciPy, numPy പാക്കേജുകളും ഗ്രാഫുകൾ വരയ്ക്കുന്നതിനുള്ള പൈപ്ലോട്ടും ഉപയോഗിച്ച്, MatLab പോലുള്ള പാക്കേജുകളുമായി പൈത്തൺ ഏതാണ്ട് താരതമ്യപ്പെടുത്താവുന്നതാണ്)

തീർച്ചയായും, ഇത് ഈ അത്ഭുതകരമായ ഭാഷ ഉപയോഗിക്കുന്ന പ്രോജക്റ്റുകളുടെ പൂർണ്ണമായ പട്ടികയല്ല.

1. വ്യാഖ്യാതാവ് തന്നെ, നിങ്ങൾക്കത് ഇവിടെ ലഭിക്കും (http://python.org/download/).
2. വികസന പരിസ്ഥിതി. ഇത് ആരംഭിക്കേണ്ട ആവശ്യമില്ല, വിതരണത്തിൽ ഉൾപ്പെടുത്തിയിരിക്കുന്ന IDLE ഒരു തുടക്കക്കാരന് അനുയോജ്യമാണ്, എന്നാൽ ഗുരുതരമായ പ്രോജക്റ്റുകൾക്ക് നിങ്ങൾക്ക് കൂടുതൽ ഗുരുതരമായ എന്തെങ്കിലും ആവശ്യമാണ്.
വിൻഡോസിനായി, Linux - Komodo IDE-ന് വേണ്ടി ഞാൻ അതിശയകരമായ ഭാരം കുറഞ്ഞ PyScripter (http://tinyurl.com/5jc63t) ഉപയോഗിക്കുന്നു.

ആദ്യ പാഠത്തിന്, പൈത്തണിൻ്റെ സംവേദനാത്മക ഷെൽ മാത്രം മതിയാകും.

python.exe പ്രവർത്തിപ്പിക്കുക. ഇൻപുട്ട് പ്രോംപ്റ്റ് ദൃശ്യമാകാൻ കൂടുതൽ സമയമെടുക്കില്ല, ഇത് ഇതുപോലെ കാണപ്പെടുന്നു:

നിങ്ങളുടെ പ്രിയപ്പെട്ട ടെക്സ്റ്റ് എഡിറ്ററിൽ py എക്സ്റ്റൻഷൻ ഉപയോഗിച്ച് ഫയലുകളിലേക്ക് പ്രോഗ്രാമുകൾ എഴുതാനും കഴിയും, അത് ടെക്സ്റ്റിലേക്ക് സ്വന്തം മാർക്ക്അപ്പ് പ്രതീകങ്ങൾ ചേർക്കുന്നില്ല (ഒരു വാക്കും പ്രവർത്തിക്കില്ല). ഈ എഡിറ്ററിന് "സ്മാർട്ട് ടാബുകൾ" നിർമ്മിക്കാൻ കഴിയുന്നതും അഭികാമ്യമാണ്, കൂടാതെ ടാബുകൾ ഉപയോഗിച്ച് സ്പേസുകൾ മാറ്റിസ്ഥാപിക്കരുത്.
നിർവ്വഹണത്തിനായി ഫയലുകൾ സമാരംഭിക്കുന്നതിന്, നിങ്ങൾക്ക് അവയിൽ ഡബിൾ ക്ലിക്ക് ചെയ്യാം. കൺസോൾ വിൻഡോ വളരെ വേഗത്തിൽ അടയ്ക്കുകയാണെങ്കിൽ, പ്രോഗ്രാമിൻ്റെ അവസാനം ഇനിപ്പറയുന്ന വരി ചേർക്കുക:

തുടർന്ന് പ്രോഗ്രാമിൻ്റെ അവസാനം എൻ്റർ അമർത്തുന്നത് വരെ വ്യാഖ്യാതാവ് കാത്തിരിക്കും.

അല്ലെങ്കിൽ ഫാർ എന്നതിലുള്ള py ഫയലുകൾ പൈത്തണുമായി ബന്ധിപ്പിച്ച് എൻ്റർ അമർത്തി തുറക്കുക.

അവസാനമായി, ഡീബഗ്ഗിംഗ് കഴിവുകൾ, വാക്യഘടന ഹൈലൈറ്റിംഗ്, മറ്റ് നിരവധി "സൗകര്യങ്ങൾ" എന്നിവ നൽകുന്ന പൈത്തണിനായി നിങ്ങൾക്ക് സൗകര്യപ്രദമായ നിരവധി ഐഡിഇകളിൽ ഒന്ന് ഉപയോഗിക്കാം.

ഒരു ചെറിയ സിദ്ധാന്തം.

തുടക്കത്തിൽ, പൈത്തൺ ശക്തമായി ചലനാത്മകമായി ടൈപ്പ് ചെയ്ത ഭാഷയാണ്. എന്താണിതിനർത്ഥം?

ശക്തമായ ടൈപ്പിംഗ് ഉള്ള ഭാഷകളുണ്ട് (പാസ്‌കൽ, ജാവ, സി, മുതലായവ), അതിൽ ഒരു വേരിയബിളിൻ്റെ തരം മുൻകൂട്ടി നിർണ്ണയിക്കുകയും മാറ്റാൻ കഴിയില്ല, കൂടാതെ ഡൈനാമിക് ടൈപ്പിംഗ് ഉള്ള ഭാഷകളും ഉണ്ട് (പൈത്തൺ, റൂബി, വിബി ), ഇതിൽ നിയുക്ത മൂല്യത്തെ ആശ്രയിച്ച് ഒരു വേരിയബിളിൻ്റെ തരം വ്യാഖ്യാനിക്കപ്പെടുന്നു.
ചലനാത്മകമായി ടൈപ്പ് ചെയ്ത ഭാഷകളെ 2 തരങ്ങളായി തിരിക്കാം. ഇംപ്ലിസിറ്റ് ടൈപ്പ് കൺവേർഷൻ (പൈത്തൺ) അനുവദിക്കാത്ത കർശനമായവ, അവ്യക്തമായവ, അവ്യക്തമായ തരം പരിവർത്തനങ്ങൾ നടത്തുന്നു (ഉദാഹരണത്തിന്, VB, അതിൽ നിങ്ങൾക്ക് "123" എന്ന സ്ട്രിംഗും 456 എന്ന നമ്പറും എളുപ്പത്തിൽ ചേർക്കാനാകും).
പൈത്തണിൻ്റെ വർഗ്ഗീകരണം കൈകാര്യം ചെയ്ത ശേഷം, ഇൻ്റർപ്രെറ്ററുമായി അൽപ്പം "കളിക്കാൻ" ശ്രമിക്കാം.

>>> a = b = 1 >>> a, b (1, 1) >>> b = 2 >>> a, b (1, 2) >>> a, b = b, a >>> a , ബി (2, 1)

അതിനാൽ, = ചിഹ്നം ഉപയോഗിച്ച് അസൈൻമെൻ്റ് നടപ്പിലാക്കുന്നത് ഞങ്ങൾ കാണുന്നു. നിങ്ങൾക്ക് ഒരേസമയം നിരവധി വേരിയബിളുകൾക്ക് ഒരു മൂല്യം നൽകാം. ഇൻ്ററാക്ടീവ് ആയി ഇൻ്റർപ്രെറ്ററിന് നിങ്ങൾ ഒരു വേരിയബിൾ പേര് നൽകുമ്പോൾ, അത് അതിൻ്റെ മൂല്യം പ്രിൻ്റ് ചെയ്യുന്നു.

നിങ്ങൾ അറിയേണ്ട അടുത്ത കാര്യം അടിസ്ഥാന അൽഗോരിതം യൂണിറ്റുകൾ എങ്ങനെ നിർമ്മിക്കപ്പെടുന്നു എന്നതാണ് - ശാഖകളും ലൂപ്പുകളും. ആരംഭിക്കുന്നതിന്, ഒരു ചെറിയ സഹായം ആവശ്യമാണ്. പൈത്തണിൽ കോഡിൻ്റെ ബ്ലോക്കുകൾക്ക് പ്രത്യേക ഡിലിമിറ്റർ ഇല്ല; ഇൻഡൻ്റേഷൻ അവയുടെ പങ്ക് നിർവഹിക്കുന്നു. അതായത്, ഒരേ ഇൻഡൻ്റേഷനിൽ എഴുതിയത് ഒരു കമാൻഡ് ബ്ലോക്ക് ആണ്. ആദ്യം ഇത് വിചിത്രമായി തോന്നിയേക്കാം, എന്നാൽ അൽപ്പം ഉപയോഗിച്ചതിന് ശേഷം, ഈ "നിർബന്ധിത" അളവ് വളരെ വായിക്കാവുന്ന കോഡ് ലഭിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നുവെന്ന് നിങ്ങൾ മനസ്സിലാക്കുന്നു.
അതിനാൽ വ്യവസ്ഥകൾ.

“:” എന്നതിൽ അവസാനിക്കുന്ന if സ്റ്റേറ്റ്‌മെൻ്റ് ഉപയോഗിച്ചാണ് വ്യവസ്ഥ വ്യക്തമാക്കുന്നത്. ആദ്യ പരിശോധന പരാജയപ്പെട്ടാൽ പാലിക്കേണ്ട ഇതര വ്യവസ്ഥകൾ elif ഓപ്പറേറ്റർ വ്യക്തമാക്കുന്നു. അവസാനമായി, വ്യവസ്ഥകളൊന്നും പാലിച്ചില്ലെങ്കിൽ എക്സിക്യൂട്ട് ചെയ്യപ്പെടുന്ന ഒരു ബ്രാഞ്ച് വ്യക്തമാക്കുന്നു.
if എന്ന് ടൈപ്പ് ചെയ്‌ത ശേഷം, കൂടുതൽ ഇൻപുട്ടിനായി കാത്തിരിക്കുകയാണെന്ന് സൂചിപ്പിക്കാൻ വ്യാഖ്യാതാവ് "..." പ്രോംപ്റ്റ് ഉപയോഗിക്കുന്നു എന്നത് ശ്രദ്ധിക്കുക. ഞങ്ങൾ പൂർത്തിയാക്കി എന്ന് അവനോട് പറയാൻ, നമ്മൾ ഒരു ശൂന്യമായ വരി നൽകണം.

(ചില കാരണങ്ങളാൽ ശാഖകളുള്ള ഉദാഹരണം, പ്രീ, കോഡ് ടാഗുകളുള്ള നൃത്തങ്ങൾ ഉണ്ടായിരുന്നിട്ടും, ഹബ്ബിലെ മാർക്ക്അപ്പ് തകർക്കുന്നു. അസൗകര്യത്തിൽ ക്ഷമിക്കണം, ഞാൻ അത് ഇവിടെ ഇട്ടിട്ടുണ്ട് pastebin.com/f66af97ba, ആരെങ്കിലും എന്നോട് എന്താണ് തെറ്റെന്ന് പറഞ്ഞാൽ, ഞാൻ ചെയ്യും വളരെ നന്ദിയുള്ളവനായിരിക്കുക)

സൈക്കിളുകൾ.

ലൂപ്പിൻ്റെ ഏറ്റവും ലളിതമായ കേസ് ലൂപ്പ് ആണ്. ഇത് ഒരു വ്യവസ്ഥയെ ഒരു പരാമീറ്ററായി എടുക്കുകയും അത് ശരിയാകുന്നിടത്തോളം എക്സിക്യൂട്ട് ചെയ്യുകയും ചെയ്യുന്നു.
ഇതാ ഒരു ചെറിയ ഉദാഹരണം.

>>> x = 0 >>> അതേസമയം x<=10: ... print x ... x += 1 ... 0 1 2 ........... 10

പ്രിൻ്റ് x, x+=1 എന്നിവ ഒരേ ഇൻഡൻ്റേഷനിൽ എഴുതിയിരിക്കുന്നതിനാൽ, അവയെ ലൂപ്പിൻ്റെ ബോഡിയായി കണക്കാക്കുന്നു (ബ്ലോക്കുകളെ കുറിച്ച് ഞാൻ പറഞ്ഞത് ഓർക്കുന്നുണ്ടോ? ;-)).

പൈത്തണിലെ രണ്ടാമത്തെ തരം ലൂപ്പ് ഫോർ ലൂപ്പാണ്. ഇത് മറ്റ് ഭാഷകളിലെ ഫോർച്ച് ലൂപ്പിന് സമാനമാണ്. അതിൻ്റെ വാക്യഘടന ഏകദേശം ഇപ്രകാരമാണ്.

പട്ടികയിലെ വേരിയബിളിനായി:
ടീമുകൾ

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

ഒരു ലളിതമായ ഉദാഹരണം ഇതാ. ലിസ്റ്റ് ഒരു സ്ട്രിംഗ് ആയിരിക്കും, അത് പ്രതീകങ്ങളുടെ ഒരു ലിസ്റ്റ് അല്ലാതെ മറ്റൊന്നുമല്ല.

>>> x = "ഹലോ, പൈത്തൺ!" >>> x-ലെ char-ന്: ... ചാർ അച്ചടിക്കുക ... H e l ........... !

ഇതുവഴി നമുക്ക് സ്ട്രിംഗിനെ പ്രതീകങ്ങളാക്കി വിഘടിപ്പിക്കാം.
ഒരു നിശ്ചിത എണ്ണം തവണ ആവർത്തിക്കുന്ന ഒരു ലൂപ്പ് വേണമെങ്കിൽ എന്തുചെയ്യണം? ഇത് വളരെ ലളിതമാണ്, റേഞ്ച് ഫംഗ്ഷൻ രക്ഷാപ്രവർത്തനത്തിലേക്ക് വരും.

ഇൻപുട്ടിൽ അത് ഒന്ന് മുതൽ മൂന്ന് വരെ പാരാമീറ്ററുകൾ എടുക്കുന്നു, ഔട്ട്പുട്ടിൽ അത് ഫോർ ഓപ്പറേറ്റർ ഉപയോഗിച്ച് നമുക്ക് "പോകാൻ" കഴിയുന്ന സംഖ്യകളുടെ ഒരു ലിസ്റ്റ് നൽകുന്നു.

റേഞ്ച് ഫംഗ്‌ഷൻ്റെ ഉപയോഗത്തിൻ്റെ ചില ഉദാഹരണങ്ങൾ ഇവിടെയുണ്ട്, അത് അതിൻ്റെ പാരാമീറ്ററുകളുടെ പങ്ക് വിശദീകരിക്കുന്നു.

>>> ശ്രേണി(10) >>> ശ്രേണി(2, 12) >>> ശ്രേണി(2, 12, 3) >>> ശ്രേണി(12, 2, -2)

ഒരു സൈക്കിൾ ഉള്ള ഒരു ചെറിയ ഉദാഹരണം.

>>> ശ്രേണിയിലുള്ള x-ന് (10): ... പ്രിൻ്റ് x ... 0 1 2 ..... 9

ഇൻപുട്ട് ഔട്ട്പുട്ട്

പൈത്തൺ പൂർണ്ണമായി ഉപയോഗിക്കാൻ തുടങ്ങുന്നതിന് മുമ്പ് നിങ്ങൾ അറിഞ്ഞിരിക്കേണ്ട അവസാന കാര്യം, അതിൽ ഇൻപുട്ട്-ഔട്ട്പുട്ട് എങ്ങനെയാണ് നടപ്പിലാക്കുന്നത് എന്നതാണ്.

ഔട്ട്പുട്ടിനായി, പ്രിൻ്റ് കമാൻഡ് ഉപയോഗിക്കുന്നു, അത് അതിൻ്റെ എല്ലാ ആർഗ്യുമെൻ്റുകളും മനുഷ്യർക്ക് വായിക്കാവുന്ന രൂപത്തിൽ പ്രിൻ്റ് ചെയ്യുന്നു.

കൺസോൾ ഇൻപുട്ടിനായി, raw_input(prompt) ഫംഗ്‌ഷൻ ഉപയോഗിക്കുന്നു, അത് ഒരു പ്രോംപ്റ്റ് പ്രദർശിപ്പിക്കുകയും ഉപയോക്തൃ ഇൻപുട്ടിനായി കാത്തിരിക്കുകയും ചെയ്യുന്നു, ഉപയോക്താവ് അതിൻ്റെ മൂല്യമായി നൽകിയത് നൽകുന്നു.

X = int(raw_input("ഒരു നമ്പർ നൽകുക:")) പ്രിൻ്റ് ചെയ്യുക "ഈ സംഖ്യയുടെ വർഗ്ഗം ", x * x ആണ്

ശ്രദ്ധ! സമാനമായ പ്രവർത്തനമുള്ള ഇൻപുട്ട്() ഫംഗ്‌ഷൻ നിലവിലുണ്ടെങ്കിലും, പ്രോഗ്രാമുകളിൽ ഇത് ഉപയോഗിക്കാൻ ശുപാർശ ചെയ്യുന്നില്ല, കാരണം ഇത് ഉപയോഗിച്ച് നൽകിയ വാക്യഘടന എക്‌സ്‌പ്രഷനുകൾ എക്‌സിക്യൂട്ട് ചെയ്യാൻ ഇൻ്റർപ്രെറ്റർ ശ്രമിക്കുന്നു, ഇത് പ്രോഗ്രാമിൻ്റെ സുരക്ഷയിൽ ഗുരുതരമായ ദ്വാരമാണ്.

ആദ്യ പാഠത്തിന് അത്രമാത്രം.

ഹോം വർക്ക്.

1. ഒരു വലത് ത്രികോണത്തിൻ്റെ ഹൈപ്പോടെനസ് കണക്കാക്കുന്നതിനുള്ള ഒരു പ്രോഗ്രാം സൃഷ്ടിക്കുക. കാലുകളുടെ നീളം ഉപയോക്താവിൽ നിന്ന് അഭ്യർത്ഥിക്കുന്നു.
2. പൊതുവായ രൂപത്തിൽ ഒരു ക്വാഡ്രാറ്റിക് സമവാക്യത്തിൻ്റെ വേരുകൾ കണ്ടെത്തുന്നതിന് ഒരു പ്രോഗ്രാം സൃഷ്ടിക്കുക. ഗുണകങ്ങൾ ഉപയോക്താവിൽ നിന്ന് അഭ്യർത്ഥിക്കുന്നു.
3. M എന്ന സംഖ്യ കൊണ്ട് ഗുണനപ്പട്ടിക പ്രദർശിപ്പിക്കുന്നതിന് ഒരു പ്രോഗ്രാം സൃഷ്‌ടിക്കുക. M * a മുതൽ M * b വരെയുള്ള പട്ടിക കംപൈൽ ചെയ്‌തിരിക്കുന്നു, ഇവിടെ M, a, b ഉപയോക്താവിൽ നിന്ന് അഭ്യർത്ഥിക്കുന്നു. ഔട്ട്‌പുട്ട് ഒരു നിരയിൽ നടത്തണം, ഇനിപ്പറയുന്ന ഫോമിൽ ഓരോ വരിയിലും ഒരു ഉദാഹരണം (ഉദാഹരണത്തിന്):
5 x 4 = 20
5 x 5 = 25
ഇത്യാദി.

പൈത്തൺ പ്രോഗ്രാമിംഗ്

ഭാഗം 1. ഭാഷാ കഴിവുകളും അടിസ്ഥാന വാക്യഘടനയും

ഉള്ളടക്ക പരമ്പര:

പൈത്തൺ പഠിക്കുന്നത് മൂല്യവത്താണോ?

ആധുനിക പ്രോഗ്രാമിംഗ് ഭാഷകളിൽ ഏറ്റവും പ്രചാരമുള്ള ഒന്നാണ് പൈത്തൺ. വൈവിധ്യമാർന്ന പ്രശ്നങ്ങൾ പരിഹരിക്കുന്നതിന് ഇത് അനുയോജ്യമാണ് കൂടാതെ മറ്റ് പ്രോഗ്രാമിംഗ് ഭാഷകളുടേതിന് സമാനമായ കഴിവുകൾ വാഗ്ദാനം ചെയ്യുന്നു: ഡൈനാമിസം, OOP പിന്തുണ, ക്രോസ്-പ്ലാറ്റ്ഫോം. പൈത്തണിൻ്റെ വികസനം 1990 കളുടെ മധ്യത്തിൽ ഗൈഡോ വാൻ റോസ്സം ആരംഭിച്ചു, അതിനാൽ ഇപ്പോൾ സാധാരണ "ബാല്യകാല" രോഗങ്ങളിൽ നിന്ന് മുക്തി നേടാനും ഭാഷയുടെ മികച്ച വശങ്ങൾ ഗണ്യമായി വികസിപ്പിക്കാനും പൈത്തൺ ഉപയോഗിച്ച് നിരവധി പ്രോഗ്രാമർമാരെ ആകർഷിക്കാനും സാധിച്ചു. പദ്ധതികൾ.

ജാവ അല്ലെങ്കിൽ സി ++ പോലുള്ള "ക്ലാസിക്" പ്രോഗ്രാമിംഗ് ഭാഷകൾ മാത്രം പഠിക്കേണ്ടത് അത്യാവശ്യമാണെന്ന് പല പ്രോഗ്രാമർമാരും വിശ്വസിക്കുന്നു, കാരണം മറ്റ് ഭാഷകൾക്ക് എന്തായാലും അതേ കഴിവുകൾ നൽകാൻ കഴിയില്ല. എന്നിരുന്നാലും, ഒരു പ്രോഗ്രാമർ ഒന്നിലധികം ഭാഷകൾ അറിയുന്നത് ഉചിതമാണെന്ന് അടുത്തിടെ ഒരു വിശ്വാസം ഉയർന്നുവന്നിട്ടുണ്ട്, ഇത് അവൻ്റെ ചക്രവാളങ്ങൾ വിശാലമാക്കുകയും പ്രശ്നങ്ങൾ കൂടുതൽ ക്രിയാത്മകമായി പരിഹരിക്കാനും തൊഴിൽ വിപണിയിലെ മത്സരശേഷി വർദ്ധിപ്പിക്കാനും അവനെ അനുവദിക്കുന്നു.

Java, C++ തുടങ്ങിയ രണ്ട് ഭാഷകൾ നന്നായി പഠിക്കുന്നത് വളരെ ബുദ്ധിമുട്ടുള്ളതും ഒരുപാട് സമയമെടുക്കുന്നതുമാണ്; കൂടാതെ, ഈ ഭാഷകളുടെ പല വശങ്ങളും പരസ്പര വിരുദ്ധമാണ്. അതേ സമയം, പൈത്തൺ ഒരു രണ്ടാം ഭാഷയുടെ റോളിന് അനുയോജ്യമാണ്, കാരണം OOP-നെക്കുറിച്ചുള്ള ഇതിനകം നിലവിലുള്ള അറിവ് കാരണം ഇത് ഉടനടി ആഗിരണം ചെയ്യപ്പെടുന്നു, കൂടാതെ അതിൻ്റെ കഴിവുകൾ പരസ്പരവിരുദ്ധമല്ല, മറിച്ച് മറ്റൊരു പ്രോഗ്രാമിംഗിൽ പ്രവർത്തിക്കുന്നതിലൂടെ നേടിയ അനുഭവത്തെ പൂരകമാക്കുന്നു. ഭാഷ.

ഒരു പ്രോഗ്രാമർ സോഫ്‌റ്റ്‌വെയർ ഡെവലപ്‌മെൻ്റ് മേഖലയിൽ ആരംഭിക്കുകയാണെങ്കിൽ, പൈത്തൺ ഒരു മികച്ച "ആമുഖ" പ്രോഗ്രാമിംഗ് ഭാഷയായിരിക്കും. അതിൻ്റെ സംക്ഷിപ്തതയ്ക്ക് നന്ദി, ഭാഷയുടെ വാക്യഘടനയിൽ വേഗത്തിൽ വൈദഗ്ദ്ധ്യം നേടാൻ ഇത് നിങ്ങളെ അനുവദിക്കും, കൂടാതെ നിരവധി വർഷങ്ങളായി രൂപംകൊണ്ട പ്രാമാണങ്ങളുടെ രൂപത്തിൽ "പൈതൃക" ത്തിൻ്റെ അഭാവം OOP വേഗത്തിൽ മാസ്റ്റർ ചെയ്യാൻ നിങ്ങളെ സഹായിക്കും. ഈ ഘടകങ്ങൾ കാരണം, പൈത്തണിനായുള്ള പഠന വക്രം വളരെ ചെറുതായിരിക്കും, കൂടാതെ പ്രോഗ്രാമർക്ക് വിദ്യാഭ്യാസ ഉദാഹരണങ്ങളിൽ നിന്ന് വാണിജ്യ പ്രോജക്റ്റുകളിലേക്ക് മാറാൻ കഴിയും.

അതിനാൽ, ഈ ലേഖനത്തിൻ്റെ വായനക്കാരൻ ആരായാലും - പരിചയസമ്പന്നനായ പ്രോഗ്രാമർ അല്ലെങ്കിൽ സോഫ്റ്റ്വെയർ വികസന മേഖലയിലെ തുടക്കക്കാരൻ, ഈ വിഭാഗത്തിൻ്റെ തലക്കെട്ടായ ചോദ്യത്തിനുള്ള ഉത്തരം "അതെ" എന്നതായിരിക്കണം.

ഭാഷയുടെ ഏറ്റവും അടിസ്ഥാന തത്വങ്ങളിൽ നിന്ന് മറ്റ് സാങ്കേതികവിദ്യകളുമായി സംയോജിപ്പിക്കുന്നതിനുള്ള വിപുലമായ കഴിവുകളിലേക്കുള്ള വിവരങ്ങൾ നൽകിക്കൊണ്ട് പഠന വക്രതയെ വിജയകരമായി മറികടക്കാൻ നിങ്ങളെ സഹായിക്കുന്നതിനാണ് ഈ ലേഖന പരമ്പര രൂപകൽപ്പന ചെയ്തിരിക്കുന്നത്. ആദ്യ ലേഖനം പൈത്തണിൻ്റെ അടിസ്ഥാന സവിശേഷതകളും വാക്യഘടനയും ഉൾക്കൊള്ളുന്നു. ഇനിപ്പറയുന്നതിൽ, ഈ ജനപ്രിയ ഭാഷയുമായി പ്രവർത്തിക്കുന്നതിൻ്റെ കൂടുതൽ വിപുലമായ വശങ്ങൾ ഞങ്ങൾ നോക്കും, പ്രത്യേകിച്ചും പൈത്തണിലെ ഒബ്ജക്റ്റ് ഓറിയൻ്റഡ് പ്രോഗ്രാമിംഗ്.

പൈത്തൺ വാസ്തുവിദ്യ

പ്രോഗ്രാമിംഗിനോ ആശയവിനിമയത്തിനോ വേണ്ടിയുള്ള ഏതൊരു ഭാഷയിലും കുറഞ്ഞത് രണ്ട് ഭാഗങ്ങളെങ്കിലും അടങ്ങിയിരിക്കുന്നു - പദാവലിയും വാക്യഘടനയും. പൈത്തൺ ഭാഷയും അതേ രീതിയിൽ ക്രമീകരിച്ചിരിക്കുന്നു, എക്സിക്യൂട്ടബിൾ പ്രോഗ്രാമുകൾ രൂപപ്പെടുത്തുന്ന എക്സ്പ്രഷനുകൾ രൂപീകരിക്കുന്നതിനുള്ള ഒരു വാക്യഘടനയും ഒരു പദാവലി - ഒരു സാധാരണ ലൈബ്രറിയുടെയും പ്ലഗ്-ഇന്നുകളുടെയും രൂപത്തിൽ ഒരു കൂട്ടം പ്രവർത്തനക്ഷമത നൽകുന്നു.

സൂചിപ്പിച്ചതുപോലെ, പൈത്തണിൻ്റെ വാക്യഘടന തികച്ചും സംക്ഷിപ്തമാണ്, പ്രത്യേകിച്ചും ജാവ അല്ലെങ്കിൽ C++ എന്നിവയുമായി താരതമ്യം ചെയ്യുമ്പോൾ. ഒരു വശത്ത്, ഇത് നല്ലതാണ്, കാരണം വാക്യഘടന ലളിതമാകുമ്പോൾ, അത് പഠിക്കുന്നത് എളുപ്പമാകും, കൂടാതെ ഇത് ഉപയോഗിക്കുമ്പോൾ നിങ്ങൾക്ക് കുറച്ച് തെറ്റുകൾ വരുത്താം. എന്നിരുന്നാലും, അത്തരം ഭാഷകൾക്ക് ഒരു പോരായ്മയുണ്ട് - അവ ലളിതമായ വിവരങ്ങൾ കൈമാറാൻ ഉപയോഗിക്കാം, സങ്കീർണ്ണമായ ഘടനകൾ പ്രകടിപ്പിക്കാൻ കഴിയില്ല.

പൈത്തണിന് ഇത് ബാധകമല്ല, കാരണം ഇത് ലളിതവും ലളിതവുമായ ഭാഷയാണ്. പൈത്തൺ ഉയർന്ന തലത്തിലുള്ള അമൂർത്തീകരണമുള്ള ഒരു ഭാഷയാണ്, ഉദാഹരണത്തിന്, ജാവ, C++ എന്നിവയേക്കാൾ ഉയർന്നത്, കൂടാതെ ചെറിയ അളവിലുള്ള സോഴ്‌സ് കോഡിൽ ഒരേ അളവിലുള്ള വിവരങ്ങൾ കൈമാറാൻ നിങ്ങളെ അനുവദിക്കുന്നു.

പൈത്തൺ ഒരു പൊതു-ഉദ്ദേശ്യ ഭാഷ കൂടിയാണ്, അതിനാൽ ഇത് സോഫ്റ്റ്‌വെയർ വികസനത്തിൻ്റെ ഏത് മേഖലയിലും (സ്റ്റാൻഡലോൺ, ക്ലയൻ്റ്-സെർവർ, വെബ് ആപ്ലിക്കേഷനുകൾ) ഏത് വിഷയ മേഖലയിലും ഉപയോഗിക്കാൻ കഴിയും. കൂടാതെ, പൈത്തൺ നിലവിലുള്ള ഘടകങ്ങളുമായി എളുപ്പത്തിൽ സംയോജിപ്പിക്കുന്നു, ഇത് ഇതിനകം എഴുതിയ ആപ്ലിക്കേഷനുകളിലേക്ക് പൈത്തൺ ഉൾപ്പെടുത്താൻ നിങ്ങളെ അനുവദിക്കുന്നു.

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

ആവശ്യമായ പ്രവർത്തനം സ്റ്റാൻഡേർഡ് പൈത്തൺ ലൈബ്രറിയിൽ ഇല്ലെങ്കിൽ, തുടർന്നുള്ള ആവർത്തിച്ചുള്ള ഉപയോഗത്തിനായി നിങ്ങൾക്ക് നിങ്ങളുടെ സ്വന്തം വിപുലീകരണ ഘടകം സൃഷ്ടിക്കാൻ കഴിയും. പൈത്തണിനായുള്ള എക്സ്റ്റൻഷൻ മൊഡ്യൂളുകൾ പൈത്തൺ ഭാഷയിൽ മാത്രമല്ല, മറ്റ് പ്രോഗ്രാമിംഗ് ഭാഷകൾ ഉപയോഗിച്ചും സൃഷ്ടിക്കാൻ കഴിയുമെന്നത് ഇവിടെ ശ്രദ്ധിക്കേണ്ടതാണ്. ഈ സാഹചര്യത്തിൽ, സങ്കീർണ്ണമായ ശാസ്ത്രീയ കണക്കുകൂട്ടലുകൾ പോലെയുള്ള റിസോഴ്സ്-ഇൻ്റൻസീവ് ടാസ്ക്കുകൾ കൂടുതൽ കാര്യക്ഷമമായി നടപ്പിലാക്കാൻ സാധിക്കും, എന്നാൽ പൈത്തൺ പോലെ എക്സ്റ്റൻഷൻ മൊഡ്യൂൾ ഭാഷ തന്നെ ക്രോസ്-പ്ലാറ്റ്ഫോമല്ലെങ്കിൽ ക്രോസ്-പ്ലാറ്റ്ഫോമിൻ്റെ പ്രയോജനം നഷ്ടപ്പെടും.

പൈത്തൺ റൺടൈം

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

ജാവ റൺടൈം എൻവയോൺമെൻ്റിൽ ഒരു കംപൈലറും ഉൾപ്പെടുന്നു, കാരണം ജാവ വെർച്വൽ മെഷീനായി സോഴ്സ് കോഡ് ബൈറ്റ്കോഡിലേക്ക് കംപൈൽ ചെയ്യണം. പൈത്തൺ റൺടൈമിൽ ഒരു ഇൻ്റർപ്രെറ്റർ മാത്രമേ ഉൾപ്പെടുന്നുള്ളൂ, അത് ഒരു കംപൈലർ കൂടിയാണ്, പക്ഷേ ടാർഗെറ്റ് പ്ലാറ്റ്‌ഫോമിലെ മെഷീൻ കോഡിലേക്ക് നേരിട്ട് പൈത്തൺ സോഴ്‌സ് കോഡ് കംപൈൽ ചെയ്യുന്നു.

പൈത്തണിനായി നിലവിൽ മൂന്ന് റൺടൈം നടപ്പിലാക്കലുകൾ ഉണ്ട്: CPython, Jython, Python.NET. പേര് സൂചിപ്പിക്കുന്നത് പോലെ, ആദ്യ ചട്ടക്കൂട് സിയിലും രണ്ടാമത്തേത് ജാവയിലും അവസാനത്തേത് .NET പ്ലാറ്റ്‌ഫോമിലും നടപ്പിലാക്കുന്നു.

CPython റൺടൈമിനെ സാധാരണയായി പൈത്തൺ എന്ന് വിളിക്കുന്നു, ആളുകൾ പൈത്തണിനെക്കുറിച്ച് സംസാരിക്കുമ്പോൾ, അവർ മിക്കപ്പോഴും അർത്ഥമാക്കുന്നത് ഈ നടപ്പാക്കലാണ്. ഈ നിർവ്വഹണത്തിൽ സിയിൽ എഴുതിയിരിക്കുന്ന ഒരു ഇൻ്റർപ്രെറ്ററും എക്സ്റ്റൻഷൻ മൊഡ്യൂളുകളും അടങ്ങിയിരിക്കുന്നു, കൂടാതെ ഒരു സ്റ്റാൻഡേർഡ് സി കംപൈലർ ലഭ്യമായ ഏത് പ്ലാറ്റ്‌ഫോമിലും ഇത് ഉപയോഗിക്കാം. കൂടാതെ, വിൻഡോസിൻ്റെ വിവിധ പതിപ്പുകൾ ഉൾപ്പെടെ വിവിധ ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങൾക്ക് റൺടൈമിൻ്റെ പ്രീ-കംപൈൽ ചെയ്ത പതിപ്പുകൾ നിലവിലുണ്ട്. OS, വിവിധ വിതരണങ്ങൾ Linux. ഇതിലും തുടർന്നുള്ള ലേഖനങ്ങളിലും, പ്രത്യേകം പ്രസ്താവിച്ചില്ലെങ്കിൽ, CPython പരിഗണിക്കും.

ജാവ വെർച്വൽ മെഷീൻ (ജെവിഎം) പ്രവർത്തിപ്പിക്കുന്നതിനുള്ള പൈത്തൺ നടപ്പാക്കലാണ് ജൈത്തൺ റൺടൈം. പതിപ്പ് 1.2.2 മുതൽ (നിലവിലെ ജാവ പതിപ്പ് 1.6 ആണ്) ആരംഭിക്കുന്ന ഏതൊരു JVM പതിപ്പും പിന്തുണയ്ക്കുന്നു. Jython-മായി പ്രവർത്തിക്കുന്നതിന് ഇൻസ്റ്റാൾ ചെയ്ത ജാവ മെഷീനും (Java Runtime environment) ജാവ പ്രോഗ്രാമിംഗ് ഭാഷയെക്കുറിച്ചുള്ള കുറച്ച് അറിവും ആവശ്യമാണ്. ജാവയിൽ സോഴ്സ് കോഡ് എങ്ങനെ എഴുതണമെന്ന് അറിയേണ്ട ആവശ്യമില്ല, എന്നാൽ നിങ്ങൾ JAR ഫയലുകളും ജാവ ആപ്ലെറ്റുകളും കൂടാതെ JavaDOC ഫോർമാറ്റിലുള്ള ഡോക്യുമെൻ്റേഷനും കൈകാര്യം ചെയ്യേണ്ടതുണ്ട്.

പരിസ്ഥിതിയുടെ ഏത് പതിപ്പാണ് തിരഞ്ഞെടുക്കേണ്ടത് എന്നത് പ്രോഗ്രാമറുടെ മുൻഗണനകളെ മാത്രം ആശ്രയിച്ചിരിക്കുന്നു; പൊതുവേ, CPython ഉം Jython ഉം കമ്പ്യൂട്ടറിൽ സൂക്ഷിക്കാൻ ശുപാർശ ചെയ്യുന്നു, കാരണം അവ പരസ്പരം വൈരുദ്ധ്യമല്ല, മറിച്ച് പരസ്പര പൂരകമാണ്. ഒരു JVM രൂപത്തിൽ ഇൻ്റർമീഡിയറ്റ് ലെയർ ഇല്ലാത്തതിനാൽ CPython എൻവയോൺമെൻ്റ് വേഗതയുള്ളതാണ്; കൂടാതെ, പൈത്തണിൻ്റെ പരിഷ്കരിച്ച പതിപ്പുകൾ ആദ്യം CPython പരിതസ്ഥിതിയായി പുറത്തിറങ്ങുന്നു. എന്നിരുന്നാലും, Jython-ന് ഏത് Java ക്ലാസ്സും ഒരു എക്സ്റ്റൻഷൻ മൊഡ്യൂളായി ഉപയോഗിക്കാനും JVM നടപ്പിലാക്കൽ നിലവിലുള്ള ഏത് പ്ലാറ്റ്ഫോമിലും പ്രവർത്തിപ്പിക്കാനും കഴിയും.

രണ്ട് റൺടൈം എൻവയോൺമെൻ്റുകളും അറിയപ്പെടുന്ന GPL ലൈസൻസിന് അനുയോജ്യമായ ഒരു ലൈസൻസിന് കീഴിലാണ് റിലീസ് ചെയ്യുന്നത്, അതിനാൽ വാണിജ്യപരവും സ്വതന്ത്രവുമായ സോഫ്‌റ്റ്‌വെയറുകൾ വികസിപ്പിക്കുന്നതിന് അവ ഉപയോഗിക്കാനാകും. മിക്ക പൈത്തൺ എക്സ്റ്റൻഷനുകളും GPL-ലൈസൻസുള്ളവയാണ്, അവ ഏത് പ്രോജക്റ്റിലും സ്വതന്ത്രമായി ഉപയോഗിക്കാവുന്നതാണ്, എന്നാൽ കൂടുതൽ കർശനമായ ലൈസൻസുകളുള്ള വാണിജ്യ വിപുലീകരണങ്ങളോ വിപുലീകരണങ്ങളോ ഉണ്ട്. അതിനാൽ, ഒരു വാണിജ്യ പ്രോജക്റ്റിൽ പൈത്തൺ ഉപയോഗിക്കുമ്പോൾ, എക്സ്റ്റൻഷൻ പ്ലഗ്-ഇൻ ലൈസൻസുകളിൽ എന്തെല്ലാം നിയന്ത്രണങ്ങൾ നിലവിലുണ്ടെന്ന് നിങ്ങൾ അറിയേണ്ടതുണ്ട്.

പൈത്തണിൽ നിന്ന് ആരംഭിക്കുന്നു

നിങ്ങൾ പൈത്തൺ ഉപയോഗിക്കാൻ തുടങ്ങുന്നതിനുമുമ്പ്, നിങ്ങൾ അതിൻ്റെ എക്സിക്യൂഷൻ എൻവയോൺമെൻ്റ് ഇൻസ്റ്റാൾ ചെയ്യേണ്ടതുണ്ട് - ഈ ലേഖനത്തിൽ ഇത് CPython ആണ്, അതനുസരിച്ച്, പൈത്തൺ ഇൻ്റർപ്രെട്ടറും. വിവിധ ഇൻസ്റ്റലേഷൻ രീതികൾ ഉണ്ട്: പരിചയസമ്പന്നരായ ഉപയോക്താക്കൾക്ക് പൈത്തണിൻ്റെ പൊതുവായി ലഭ്യമായ സോഴ്‌സ് കോഡിൽ നിന്ന് സ്വയം കംപൈൽ ചെയ്യാൻ കഴിയും, കൂടാതെ www.python.org എന്ന വെബ്‌സൈറ്റിൽ നിന്ന് ഒരു നിർദ്ദിഷ്ട ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തിനായുള്ള റെഡിമെയ്ഡ് എക്‌സിക്യൂട്ടബിൾ ഫയലുകൾ ഡൗൺലോഡ് ചെയ്യാനും കഴിയും, ഒടുവിൽ, നിരവധി ലിനക്സ് വിതരണങ്ങൾ വരുന്നു. മുൻകൂട്ടി ഇൻസ്റ്റാൾ ചെയ്ത പൈത്തൺ ഇൻ്റർപ്രെറ്റർ ഉപയോഗിച്ച്. ഈ ലേഖനം പൈത്തൺ 2.x-ൻ്റെ വിൻഡോസ് പതിപ്പ് ഉപയോഗിക്കുന്നു, എന്നാൽ അവതരിപ്പിച്ച ഉദാഹരണങ്ങൾ പൈത്തണിൻ്റെ ഏത് പതിപ്പിലും പ്രവർത്തിപ്പിക്കാൻ കഴിയും.

നിർദ്ദിഷ്ട ഡയറക്ടറിയിലേക്ക് ഇൻസ്റ്റാളർ പൈത്തൺ എക്സിക്യൂട്ടബിളുകൾ വിന്യസിച്ച ശേഷം, ഇനിപ്പറയുന്ന സിസ്റ്റം വേരിയബിളുകളുടെ മൂല്യങ്ങൾ നിങ്ങൾ പരിശോധിക്കേണ്ടതുണ്ട്:

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

ഇൻ്റർപ്രെറ്ററുമായി പ്രവർത്തിക്കുന്നതിനുള്ള കമാൻഡ് ലൈനിന് ഇനിപ്പറയുന്ന ഘടനയുണ്ട്.

PYTHONHOME\python (ഓപ്ഷനുകൾ) [ -c കമാൻഡ് | സ്ക്രിപ്റ്റ് ഫയൽ | - ] (വാദങ്ങൾ)

പൈത്തൺ ഇൻ്ററാക്ടീവ് മോഡ്

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

മൂല്യനിർണ്ണയ പദപ്രയോഗത്തിൻ്റെ മൂല്യം സിംഗിൾ അണ്ടർസ്‌കോർ (_) എന്ന പ്രത്യേക വേരിയബിളിൽ സംഭരിച്ചിരിക്കുന്നതിനാൽ അത് തുടർന്നുള്ള എക്‌സ്‌പ്രഷനുകളിൽ ഉപയോഗിക്കാനാകും. Windows-ലെ Ctrl-Z അല്ലെങ്കിൽ Linux-ൽ Ctrl-D എന്ന കീബോർഡ് കുറുക്കുവഴി ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഒരു ഇൻ്ററാക്ടീവ് സെഷൻ അവസാനിപ്പിക്കാം.

ഒരു സെഷനിൽ വ്യാഖ്യാതാവിൻ്റെ സ്വഭാവം മാറ്റാൻ കഴിയുന്ന ഓപ്ഷണൽ സ്ട്രിംഗ് മൂല്യങ്ങളാണ് ഓപ്ഷനുകൾ; അവയുടെ പ്രാധാന്യം ഇതിലും തുടർന്നുള്ള ലേഖനങ്ങളിലും ചർച്ച ചെയ്യും. വ്യാഖ്യാതാവ് എക്സിക്യൂട്ട് ചെയ്യേണ്ട ഒരു നിർദ്ദിഷ്ട കമാൻഡ് അല്ലെങ്കിൽ എക്സിക്യൂട്ട് ചെയ്യേണ്ട സ്ക്രിപ്റ്റ് അടങ്ങുന്ന ഫയലിലേക്കുള്ള പാത ഓപ്ഷനുകൾ വ്യക്തമാക്കുന്നു. ഒരു കമാൻഡിന് അർദ്ധവിരാമങ്ങളാൽ വേർതിരിച്ച നിരവധി പദപ്രയോഗങ്ങൾ അടങ്ങിയിരിക്കാമെന്നത് ശ്രദ്ധിക്കേണ്ടതാണ്, കൂടാതെ ഉദ്ധരണികളിൽ ഉൾപ്പെടുത്തിയിരിക്കണം, അതുവഴി ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തിന് അത് ഇൻ്റർപ്രെറ്ററിന് ശരിയായി കൈമാറാൻ കഴിയും. എക്സിക്യൂട്ടബിൾ സ്ക്രിപ്റ്റിലേക്കുള്ള തുടർന്നുള്ള പ്രോസസ്സിംഗിനായി കൈമാറുന്ന പരാമീറ്ററുകളാണ് ആർഗ്യുമെൻ്റുകൾ; അവ സ്ട്രിംഗുകളായി പ്രോഗ്രാമിലേക്ക് കൈമാറുകയും സ്‌പെയ്‌സുകളാൽ വേർതിരിക്കുകയും ചെയ്യുന്നു.

പൈത്തൺ ശരിയായി ഇൻസ്റ്റാൾ ചെയ്തിട്ടുണ്ടെന്നും ശരിയായി പ്രവർത്തിക്കുന്നുണ്ടെന്നും പരിശോധിക്കാൻ, നിങ്ങൾക്ക് ഇനിപ്പറയുന്ന കമാൻഡുകൾ പ്രവർത്തിപ്പിക്കാം:

c:\>പൈത്തൺ-വി
c:\> python –c “ഇറക്കുമതി സമയം; അച്ചടി സമയം.asctime()”

-v ഓപ്ഷൻ ഉപയോഗിക്കുന്ന പൈത്തൺ നടപ്പിലാക്കലിൻ്റെ പതിപ്പ് പ്രിൻ്റ് ചെയ്യുകയും പുറത്തുകടക്കുകയും ചെയ്യുന്നു, രണ്ടാമത്തെ കമാൻഡ് സിസ്റ്റം സമയ മൂല്യം സ്ക്രീനിലേക്ക് പ്രിൻ്റ് ചെയ്യുന്നു.

നിങ്ങൾക്ക് ഏത് ടെക്സ്റ്റ് എഡിറ്ററിലും പൈത്തൺ സ്ക്രിപ്റ്റുകൾ എഴുതാം, കാരണം അവ സാധാരണ ടെക്സ്റ്റ് ഫയലുകളാണ്, പക്ഷേ പൈത്തണിനൊപ്പം പ്രവർത്തിക്കാൻ രൂപകൽപ്പന ചെയ്ത പ്രത്യേക വികസന പരിതസ്ഥിതികളും ഉണ്ട്.

പൈത്തൺ സിൻ്റാക്സ് അടിസ്ഥാനങ്ങൾ

പൈത്തൺ സോഴ്സ് കോഡ് സ്ക്രിപ്റ്റുകൾ എന്ന് വിളിക്കപ്പെടുന്നവ അടങ്ങിയിരിക്കുന്നു ലോജിക്കൽ സ്ട്രിംഗുകൾ, അവയിൽ ഓരോന്നും അടങ്ങുന്നു ഫിസിക്കൽ ലൈനുകൾ. അഭിപ്രായങ്ങളെ സൂചിപ്പിക്കാൻ # ചിഹ്നം ഉപയോഗിക്കുന്നു. വ്യാഖ്യാതാവ് അഭിപ്രായങ്ങളും ശൂന്യമായ വരികളും അവഗണിക്കുന്നു.

രണ്ടാമത്തെ പ്രോഗ്രാമിംഗ് ഭാഷയായി പൈത്തൺ പഠിക്കുന്ന പ്രോഗ്രാമർമാർക്ക് വിചിത്രമായി തോന്നിയേക്കാവുന്ന വളരെ പ്രധാനപ്പെട്ട ഒരു വശമാണ് ഇനിപ്പറയുന്നത്. സി++ അല്ലെങ്കിൽ ജാവയിലെ അർദ്ധവിരാമം (;) പോലുള്ള സോഴ്‌സ് കോഡിലെ പദപ്രയോഗങ്ങൾ പരസ്പരം വേർതിരിക്കുന്നതിന് ഉത്തരവാദിയായ ഒരു ചിഹ്നവും പൈത്തണിൽ ഇല്ല എന്നതാണ് വസ്തുത. ഒരേ ഫിസിക്കൽ ലൈനിലാണെങ്കിൽ ഒന്നിലധികം നിർദ്ദേശങ്ങൾ വേർതിരിക്കാൻ ഒരു അർദ്ധവിരാമം നിങ്ങളെ അനുവദിക്കുന്നു. ഒരു കൂട്ടം നിർദ്ദേശങ്ങൾ ഒരൊറ്റ ബ്ലോക്കിലേക്ക് സംയോജിപ്പിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്ന ചുരുണ്ട ബ്രേസുകൾ () പോലെയുള്ള ഒരു നിർമ്മാണവും ഇല്ല.

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

മറ്റ് പ്രോഗ്രാമിംഗ് ഭാഷകളിൽ നിന്ന് പൈത്തൺ വാക്യഘടനയിൽ മറ്റ് സമൂലമായ വ്യത്യാസങ്ങളൊന്നുമില്ല. ഒരു സ്റ്റാൻഡേർഡ് സെറ്റ് ഓപ്പറേറ്റർമാരും കീവേഡുകളും ഉണ്ട്, അവയിൽ മിക്കതും പ്രോഗ്രാമർമാർക്ക് ഇതിനകം പരിചിതമാണ്, അതേസമയം പൈത്തൺ-നിർദ്ദിഷ്ടമായവ ഇതിലും തുടർന്നുള്ള ലേഖനങ്ങളിലും ഉൾപ്പെടുത്തും. വേരിയബിളുകൾ, രീതികൾ, ക്ലാസുകൾ എന്നിവയുടെ ഐഡൻ്റിഫയറുകൾ വ്യക്തമാക്കുന്നതിനും സ്റ്റാൻഡേർഡ് നിയമങ്ങൾ ഉപയോഗിക്കുന്നു - പേര് ഏതെങ്കിലും കേസിൻ്റെ അണ്ടർസ്കോറോ ലാറ്റിൻ പ്രതീകമോ ഉപയോഗിച്ച് ആരംഭിക്കണം, കൂടാതെ @, $, % പ്രതീകങ്ങൾ അടങ്ങിയിരിക്കരുത്. കൂടാതെ, ഒരു ഐഡൻ്റിഫയറായി അടിവരയിടുന്ന ഒരു പ്രതീകം മാത്രം ഉപയോഗിക്കാൻ കഴിയില്ല (ഇൻ്ററാക്റ്റീവ് മോഡ് പ്രവർത്തനത്തെക്കുറിച്ച് പറയുന്ന അടിക്കുറിപ്പ് കാണുക).

പൈത്തണിൽ ഉപയോഗിക്കുന്ന ഡാറ്റ തരങ്ങൾ

പൈത്തണിൽ ഉപയോഗിക്കുന്ന ഡാറ്റ തരങ്ങളും മറ്റ് ഭാഷകൾക്ക് സമാനമാണ് - പൂർണ്ണസംഖ്യയും യഥാർത്ഥ ഡാറ്റ തരങ്ങളും; കൂടാതെ, സങ്കീർണ്ണമായ ഒരു ഡാറ്റാ തരം പിന്തുണയ്ക്കുന്നു - യഥാർത്ഥവും സാങ്കൽപ്പികവുമായ ഭാഗം (അത്തരം ഒരു സംഖ്യയുടെ ഒരു ഉദാഹരണം 1.5J അല്ലെങ്കിൽ 2j ആണ്, ഇവിടെ J എന്നത് -1 ൻ്റെ വർഗ്ഗമൂലമാണ്). സിംഗിൾ, ഡബിൾ അല്ലെങ്കിൽ ട്രിപ്പിൾ ഉദ്ധരണികളിൽ ഉൾപ്പെടുത്താവുന്ന സ്ട്രിംഗുകൾ പൈത്തൺ പിന്തുണയ്ക്കുന്നു, കൂടാതെ ജാവ പോലെയുള്ള സ്ട്രിംഗുകൾ മാറ്റമില്ലാത്ത വസ്തുക്കളാണ്, അതായത്. സൃഷ്ടിച്ചതിനുശേഷം അവയുടെ മൂല്യം മാറ്റാൻ കഴിയില്ല.

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

ഡാറ്റാ സെറ്റുകളിൽ പ്രവർത്തിക്കുന്നതിനുള്ള പ്രവർത്തനം

ഡാറ്റാ സെറ്റുകൾ സംഭരിക്കുന്നതിനുള്ള മൂന്ന് തരം ശേഖരങ്ങളെ പൈത്തൺ നിർവ്വചിക്കുന്നു:

• ട്യൂപ്പിൾ (ട്യൂപ്പിൾ);
• പട്ടിക (ലിസ്റ്റ്);
• നിഘണ്ടു.

ഒരു ട്യൂപ്പിൾ എന്നത് ഒരു മാറ്റമില്ലാത്ത ക്രമപ്പെടുത്തിയ ഡാറ്റയുടെ ക്രമമാണ്. മറ്റ് ട്യൂപ്പിളുകൾ പോലെയുള്ള വ്യത്യസ്ത തരത്തിലുള്ള ഘടകങ്ങൾ ഇതിൽ അടങ്ങിയിരിക്കാം. ഒരു ട്യൂപ്പിൾ പരാൻതീസിസിൽ നിർവചിച്ചിരിക്കുന്നു, അതിൻ്റെ മൂലകങ്ങളെ കോമകളാൽ വേർതിരിക്കുന്നു. ഒരു പ്രത്യേക ബിൽറ്റ്-ഇൻ ഫംഗ്ഷൻ, tuple(), തന്നിരിക്കുന്ന ഡാറ്റയുടെ ക്രമത്തിൽ നിന്ന് ട്യൂപ്പിളുകൾ സൃഷ്ടിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു.

ഒരു ലിസ്റ്റ് എന്നത് മൂലകങ്ങളുടെ മ്യൂട്ടബിൾ, ഓർഡർ ചെയ്ത ക്രമമാണ്. ലിസ്റ്റ് ഘടകങ്ങളും കോമകളാൽ വേർതിരിക്കപ്പെടുന്നു, എന്നാൽ ചതുര ബ്രാക്കറ്റുകളിൽ വ്യക്തമാക്കിയിരിക്കുന്നു. ലിസ്റ്റുകൾ സൃഷ്ടിക്കുന്നതിന്, ലിസ്റ്റ്() ഫംഗ്ഷൻ നിർദ്ദേശിക്കപ്പെടുന്നു.

ഒരു ഘടകത്തെ അതിൻ്റെ ഐഡൻ്റിഫയർ കീയ്‌ക്കൊപ്പം സംഭരിക്കുന്ന ഒരു ഹാഷ് പട്ടികയാണ് നിഘണ്ടു. മൂലകങ്ങളിലേക്കുള്ള തുടർന്നുള്ള ആക്സസും കീ വഴിയാണ് നടത്തുന്നത്, അതിനാൽ ഒരു നിഘണ്ടുവിലെ സ്റ്റോറേജ് യൂണിറ്റ് ഒരു ഒബ്ജക്റ്റ്-കീ ജോഡിയും അനുബന്ധ മൂല്യമുള്ള ഒബ്ജക്റ്റും ആണ്. നിഘണ്ടു എന്നത് മാറ്റാവുന്നതും എന്നാൽ ക്രമപ്പെടുത്താത്തതുമായ ശേഖരമാണ്, അതിനാൽ നിഘണ്ടുവിലെ മൂലകങ്ങളുടെ ക്രമം കാലക്രമേണ മാറാം. നിഘണ്ടു ചുരുണ്ട ബ്രേസുകളിൽ വ്യക്തമാക്കിയിരിക്കുന്നു, കീ മൂല്യത്തിൽ നിന്ന് ഒരു കോളൻ കൊണ്ട് വേർതിരിച്ചിരിക്കുന്നു, കൂടാതെ കീ/മൂല്യം ജോഡികൾ തന്നെ കോമകളാൽ വേർതിരിക്കപ്പെടുന്നു. നിഘണ്ടുക്കൾ സൃഷ്ടിക്കാൻ dict() ഫംഗ്ഷൻ ലഭ്യമാണ്.

പൈത്തണിൽ ലഭ്യമായ വിവിധ ശേഖരങ്ങളുടെ ഉദാഹരണങ്ങൾ പട്ടിക 1 കാണിക്കുന്നു.

ലിസ്റ്റിംഗ് 1. പൈത്തണിൽ ലഭ്യമായ ശേഖരങ്ങളുടെ തരങ്ങൾ

പൈത്തണിലെ ഫംഗ്‌ഷനുകൾ നിർവചിക്കുന്നു

പൈത്തൺ OOP പിന്തുണയ്ക്കുന്നുണ്ടെങ്കിലും, അതിൻ്റെ പല സവിശേഷതകളും പ്രത്യേക ഫംഗ്ഷനുകളായി നടപ്പിലാക്കുന്നു; കൂടാതെ, വിപുലീകരണ മൊഡ്യൂളുകൾ മിക്കപ്പോഴും ഫംഗ്ഷനുകളുടെ ഒരു ലൈബ്രറിയുടെ രൂപത്തിലാണ് നിർമ്മിച്ചിരിക്കുന്നത്. ക്ലാസുകളിലും ഫംഗ്ഷനുകൾ ഉപയോഗിക്കുന്നു, അവ പരമ്പരാഗതമായി രീതികൾ എന്ന് വിളിക്കുന്നു.

പൈത്തണിലെ ഫംഗ്‌ഷനുകൾ നിർവചിക്കുന്നതിനുള്ള വാക്യഘടന വളരെ ലളിതമാണ്; മേൽപ്പറഞ്ഞ ആവശ്യകതകൾ കണക്കിലെടുക്കുന്നു:

നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, def, colon, indentation എന്നീ ഫംഗ്ഷൻ വാക്ക് ഉപയോഗിക്കേണ്ടത് ആവശ്യമാണ്. ഫംഗ്ഷൻ വിളിക്കുന്നതും വളരെ ലളിതമാണ്:

പൈത്തൺ-നിർദ്ദിഷ്‌ടമായ ചില കാര്യങ്ങൾ പരിഗണിക്കാനുണ്ട്. ജാവയിലെന്നപോലെ, പ്രാകൃത മൂല്യങ്ങൾ മൂല്യത്തിനനുസരിച്ച് കടന്നുപോകുന്നു (പാരാമീറ്ററിൻ്റെ ഒരു പകർപ്പ് ഫംഗ്‌ഷനിലേക്ക് കൈമാറുന്നു, കൂടാതെ ഫംഗ്‌ഷൻ വിളിക്കുന്നതിന് മുമ്പ് സജ്ജമാക്കിയ മൂല്യം ഇതിന് മാറ്റാൻ കഴിയില്ല), കൂടാതെ സങ്കീർണ്ണമായ ഒബ്‌ജക്റ്റ് തരങ്ങൾ റഫറൻസ് വഴി കൈമാറുന്നു (ഒരു റഫറൻസ് ആണ് ഫംഗ്‌ഷനിലേക്ക് കടന്നുപോയി, അത് ഒബ്‌ജക്‌റ്റിനെ നന്നായി മാറ്റിയേക്കാം).

ലിസ്റ്റിംഗ് ഓർഡറോ പേരോ ഉപയോഗിച്ച് പാരാമീറ്ററുകൾ കൈമാറാൻ കഴിയും; ഈ സാഹചര്യത്തിൽ, സ്ഥിരസ്ഥിതി മൂല്യങ്ങളുള്ള ആ പാരാമീറ്ററുകൾ വിളിക്കുമ്പോൾ നിങ്ങൾ വ്യക്തമാക്കേണ്ടതില്ല, എന്നാൽ ആവശ്യമുള്ളവ മാത്രം നൽകുക അല്ലെങ്കിൽ ഒരു ഫംഗ്ഷൻ വിളിക്കുമ്പോൾ പാരാമീറ്ററുകളുടെ ക്രമം മാറ്റുക. :

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

ഫംഗ്‌ഷൻ വളരെ ലളിതവും ഒരു ലൈൻ അടങ്ങിയതുമാണെങ്കിൽ, അത് ഉപയോഗിക്കുന്ന ഘട്ടത്തിൽ തന്നെ നിർവചിക്കാം; പൈത്തണിൽ, അത്തരമൊരു നിർമ്മാണത്തെ ലാംഡ ഫംഗ്ഷൻ എന്ന് വിളിക്കുന്നു. ലാംഡ ഫംഗ്‌ഷൻ എന്നത് ഒരു അജ്ഞാത ഫംഗ്‌ഷനാണ് (അതിൻ്റെ സ്വന്തം പേരില്ലാതെ), അതിൻ്റെ ബോഡി ചില പദപ്രയോഗത്തിൻ്റെ മൂല്യം നൽകുന്ന ഒരു റിട്ടേൺ സ്റ്റേറ്റ്‌മെൻ്റാണ്. ഈ സമീപനം ചില സാഹചര്യങ്ങളിൽ സൗകര്യപ്രദമായിരിക്കാം, എന്നാൽ അത്തരം ഫംഗ്ഷനുകൾ വീണ്ടും ഉപയോഗിക്കുന്നത് അസാധ്യമാണെന്നത് ശ്രദ്ധിക്കേണ്ടതാണ് ("അത് എവിടെയാണ് ജനിച്ചത്, അത് ഉപയോഗപ്രദമാണ്").

ആവർത്തനത്തിൻ്റെ ഉപയോഗത്തോടുള്ള പൈത്തണിൻ്റെ മനോഭാവം വിവരിക്കുന്നത് മൂല്യവത്താണ്. ഡിഫോൾട്ടായി, ആവർത്തന ഡെപ്ത് 1000 ലെവലിലേക്ക് പരിമിതപ്പെടുത്തിയിരിക്കുന്നു, ഈ ലെവൽ കടന്നുപോകുമ്പോൾ, ഒരു അപവാദം ഉയർത്തുകയും പ്രോഗ്രാം പ്രവർത്തിക്കുന്നത് നിർത്തുകയും ചെയ്യും. എന്നിരുന്നാലും, ആവശ്യമെങ്കിൽ, ഈ പരിധിയുടെ മൂല്യം മാറ്റാവുന്നതാണ്.

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

അതിൽ, ഘനീഭവിച്ച രൂപത്തിൽ,
പൈത്തൺ ഭാഷയുടെ അടിസ്ഥാനകാര്യങ്ങളെക്കുറിച്ച് സംസാരിക്കുക. ഈ ലേഖനത്തിൻ്റെ വിവർത്തനം ഞാൻ നിങ്ങൾക്ക് വാഗ്ദാനം ചെയ്യുന്നു. വിവർത്തനം അക്ഷരാർത്ഥത്തിൽ അല്ല. വ്യക്തമല്ലാത്ത ചില പോയിൻ്റുകൾ കൂടുതൽ വിശദമായി വിശദീകരിക്കാൻ ഞാൻ ശ്രമിച്ചു.

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

അടിസ്ഥാന ഗുണങ്ങൾ

പൈത്തണിന് വേരിയബിളുകളുടെ വ്യക്തമായ പ്രഖ്യാപനം ആവശ്യമില്ല, കൂടാതെ ഒരു കേസ്-സെൻസിറ്റീവ് ആണ് (var വേരിയബിൾ Var അല്ലെങ്കിൽ VAR-ന് തുല്യമല്ല - അവ മൂന്ന് വ്യത്യസ്ത വേരിയബിളുകളാണ്) ഒബ്ജക്റ്റ്-ഓറിയൻ്റഡ് ഭാഷ.

വാക്യഘടന

ഒന്നാമതായി, പൈത്തണിൻ്റെ രസകരമായ ഒരു സവിശേഷത ശ്രദ്ധിക്കേണ്ടതാണ്. അതിൽ ഓപ്പറേറ്റർ ബ്രാക്കറ്റുകൾ അടങ്ങിയിട്ടില്ല (ആരംഭിക്കുക..അവസാനം പാസ്കലിൽ അല്ലെങ്കിൽ (..) സിയിൽ), പകരം ബ്ലോക്കുകൾ ഇൻഡൻ്റ് ചെയ്തിട്ടുണ്ട്: സ്‌പെയ്‌സുകൾ അല്ലെങ്കിൽ ടാബുകൾ, കൂടാതെ ഒരു കോളൺ ഉപയോഗിച്ചാണ് സ്റ്റേറ്റ്‌മെൻ്റുകളുടെ ഒരു ബ്ലോക്ക് നൽകുന്നത്. സിംഗിൾ-ലൈൻ കമൻ്റുകൾ "#" എന്ന പൗണ്ട് ചിഹ്നത്തിൽ ആരംഭിക്കുന്നു, മൾട്ടി-ലൈൻ കമൻ്റുകൾ മൂന്ന് ഇരട്ട ഉദ്ധരണികളിൽ """" ആരംഭിക്കുകയും അവസാനിക്കുകയും ചെയ്യുന്നു.
ഒരു വേരിയബിളിന് ഒരു മൂല്യം നൽകുന്നതിന്, “=” ചിഹ്നം ഉപയോഗിക്കുക, താരതമ്യം ചെയ്യാൻ -
"==". ഒരു വേരിയബിളിൻ്റെ മൂല്യം വർദ്ധിപ്പിക്കുന്നതിനോ ഒരു സ്‌ട്രിംഗിലേക്ക് ചേർക്കുന്നതിനോ, അത് കുറയ്ക്കുന്നതിന് “+=” ഓപ്പറേറ്ററും “-=” ഉം ഉപയോഗിക്കുക. ഈ പ്രവർത്തനങ്ങൾക്കെല്ലാം സ്ട്രിംഗുകൾ ഉൾപ്പെടെ മിക്ക തരങ്ങളുമായും സംവദിക്കാൻ കഴിയും. ഉദാഹരണത്തിന്

>>> myvar = 3
>>> myvar += 2
>>> myvar -= 1
""ഇതൊരു മൾട്ടി-ലൈൻ കമൻ്റാണ്
മൂന്ന് ഇരട്ട ഉദ്ധരണികളിൽ ഉൾപ്പെടുത്തിയിരിക്കുന്ന വരികൾ അവഗണിക്കപ്പെട്ടു"""
>>> mystring = "ഹലോ"
>>> mystring += "ലോകം."
>>> അച്ചടിക്കുകമർമ്മം
ഹലോ വേൾഡ്.
# അടുത്ത വരി മാറുന്നു
വേരിയബിളുകളുടെ മൂല്യങ്ങൾ സ്വാപ്പ് ചെയ്യപ്പെടുന്നു. (ഒരു വരി മാത്രം!)
>>> myvar, mystring = mystring, myvar

ഡാറ്റ ഘടനകൾ

പോലുള്ള ഡാറ്റാ ഘടനകൾ പൈത്തണിൽ അടങ്ങിയിരിക്കുന്നു ലിസ്റ്റുകൾ, ട്യൂപ്പിൾസ്, നിഘണ്ടുക്കൾ). ലിസ്റ്റുകൾ ഏകമാന അറേകൾക്ക് സമാനമാണ് (എന്നാൽ നിങ്ങൾക്ക് ലിസ്റ്റുകൾ അടങ്ങിയ ഒരു ലിസ്റ്റ് ഉപയോഗിക്കാം - ഒരു മൾട്ടിഡൈമെൻഷണൽ അറേ), ട്യൂപ്പിൾസ് മാറ്റമില്ലാത്ത ലിസ്റ്റുകളാണ്, നിഘണ്ടുക്കളും ലിസ്റ്റുകളാണ്, എന്നാൽ സൂചികകൾ സംഖ്യ മാത്രമല്ല, ഏത് തരത്തിലും ആകാം. പൈത്തണിലെ "അറേകളിൽ" ഏത് തരത്തിലുമുള്ള ഡാറ്റ അടങ്ങിയിരിക്കാം, അതായത്, ഒരു അറേയിൽ സംഖ്യ, സ്ട്രിംഗ്, മറ്റ് ഡാറ്റ തരങ്ങൾ എന്നിവ അടങ്ങിയിരിക്കാം. അറേകൾ സൂചിക 0-ൽ ആരംഭിക്കുന്നു, അവസാന ഘടകം സൂചിക -1-ൽ ആക്‌സസ് ചെയ്യാൻ കഴിയും, നിങ്ങൾക്ക് വേരിയബിളുകൾക്ക് ഫംഗ്‌ഷനുകൾ നൽകുകയും അതിനനുസരിച്ച് അവ ഉപയോഗിക്കുകയും ചെയ്യാം.

>>> സാമ്പിൾ = , ("a" , "tuple" )] #പട്ടികയിൽ ഒരു പൂർണ്ണസംഖ്യയും മറ്റൊരു ലിസ്റ്റും ഒരു ട്യൂപ്പിളും അടങ്ങിയിരിക്കുന്നു
>>> #ഈ ലിസ്റ്റിൽ ഒരു സ്ട്രിംഗ്, ഒരു പൂർണ്ണസംഖ്യ, ഒരു ഭിന്നസംഖ്യ എന്നിവ അടങ്ങിയിരിക്കുന്നു
>>> mylist = "ലിസ്റ്റ് ഇനം 1 വീണ്ടും" #ഷീറ്റ് മൈലിസ്റ്റിൻ്റെ ആദ്യ (പൂജ്യം) ഘടകം മാറ്റുക
>>> mylist[-1 ] = 3 .14 #ഷീറ്റിൻ്റെ അവസാന ഘടകം മാറ്റുക
>>> mydict = ("കീ 1" : "മൂല്യം 1" , 2 : 3 , "pi" : 3 .14 ) #സംഖ്യാ, പൂർണ്ണസംഖ്യ സൂചികകൾ ഉപയോഗിച്ച് ഒരു നിഘണ്ടു സൃഷ്ടിക്കുക
>>> mydict[“pi” ] = 3 .15 "പൈ" എന്ന സൂചികയ്ക്ക് കീഴിലുള്ള നിഘണ്ടു ഘടകം മാറ്റുക.
>>> mytuple = (1 , 2 , 3 ) #ഒരു tuple വ്യക്തമാക്കുക
>>> myfunction = ലെൻ ഈ രീതിയിൽ ഫംഗ്‌ഷൻ പര്യായങ്ങൾ പ്രഖ്യാപിക്കാൻ #Python നിങ്ങളെ അനുവദിക്കുന്നു
>>> അച്ചടിക്കുകഎൻ്റെ പ്രവർത്തനം (പട്ടിക)
3

":" എന്ന കോളൻ കൊണ്ട് വേർതിരിച്ച ആദ്യത്തേയും അവസാനത്തേയും സൂചിക വ്യക്തമാക്കിക്കൊണ്ട് നിങ്ങൾക്ക് ഒരു അറേയുടെ ഭാഗം ഉപയോഗിക്കാം. ഈ സാഹചര്യത്തിൽ, നിങ്ങൾക്ക് അറേയുടെ ഒരു ഭാഗം ലഭിക്കും, ആദ്യ സൂചിക മുതൽ രണ്ടാമത്തേത് വരെ, ഉൾപ്പെടുന്നില്ല. ആദ്യ ഘടകം വ്യക്തമാക്കിയിട്ടില്ലെങ്കിൽ, അറേയുടെ ആരംഭം മുതൽ എണ്ണം ആരംഭിക്കുന്നു, അവസാന ഘടകം വ്യക്തമാക്കിയിട്ടില്ലെങ്കിൽ, അറേ അവസാന ഘടകത്തിലേക്ക് റീഡ് ചെയ്യും. നെഗറ്റീവ് മൂല്യങ്ങൾ മൂലകത്തിൻ്റെ സ്ഥാനം അവസാനം മുതൽ നിർണ്ണയിക്കുന്നു. ഉദാഹരണത്തിന്:

>>> mylist = [“ലിസ്റ്റ് ഇനം 1” , 2 , 3 .14 ]
>>> അച്ചടിക്കുക mylist[:] #അറേയുടെ എല്ലാ ഘടകങ്ങളും വായിച്ചു
["ലിസ്റ്റ് ഇനം 1" , 2 , 3 .14000000000000001 ]
>>> അച്ചടിക്കുകമൈലിസ്റ്റ് #അറേയുടെ പൂജ്യവും ആദ്യ ഘടകവും വായിക്കുന്നു.
["ലിസ്റ്റ് ഇനം 1" , 2 ]
>>> അച്ചടിക്കുക mylist[-3 :-1 ] #മൂലകങ്ങൾ പൂജ്യം (-3) മുതൽ സെക്കൻഡ് (-1) വരെ വായിക്കുന്നു (ഉൾപ്പെടെയല്ല)
["ലിസ്റ്റ് ഇനം 1" , 2 ]
>>> അച്ചടിക്കുകമൈലിസ്റ്റ് # ഘടകങ്ങൾ ആദ്യം മുതൽ അവസാനം വരെ വായിക്കുന്നു

സ്ട്രിംഗുകൾ

പൈത്തണിലെ സ്ട്രിംഗുകൾ ഇരട്ട ഉദ്ധരണികൾ """ അല്ലെങ്കിൽ ഒറ്റ ഉദ്ധരണികൾ """ കൊണ്ട് വേർതിരിച്ചിരിക്കുന്നു. ഇരട്ട ഉദ്ധരണികളിൽ ഒറ്റ ഉദ്ധരണികൾ അടങ്ങിയിരിക്കാം, അല്ലെങ്കിൽ തിരിച്ചും. ഉദാഹരണത്തിന്, "അവൻ ഹലോ പറഞ്ഞു!" "അവൻ ഹായ് പറഞ്ഞു!" എന്ന് പ്രദർശിപ്പിക്കും. നിങ്ങൾക്ക് നിരവധി വരികളുടെ ഒരു സ്ട്രിംഗ് ഉപയോഗിക്കണമെങ്കിൽ, """" എന്ന മൂന്ന് ഇരട്ട ഉദ്ധരണികളിൽ ഈ ലൈൻ ആരംഭിക്കുകയും അവസാനിക്കുകയും വേണം. നിങ്ങൾക്ക് ട്യൂപ്പിൾ അല്ലെങ്കിൽ നിഘണ്ടുവിൽ നിന്നുള്ള ഘടകങ്ങൾ സ്ട്രിംഗ് ടെംപ്ലേറ്റിലേക്ക് മാറ്റിസ്ഥാപിക്കാം. സ്ട്രിംഗിന് ഇടയിലുള്ള ശതമാനം ചിഹ്നം "%" കൂടാതെ "%s" എന്ന സ്ട്രിംഗിലെ പ്രതീകങ്ങളെ ട്യൂപ്പിൾ ഒരു ട്യൂപ്പിൾ എലമെൻ്റിലേക്ക് മാറ്റിസ്ഥാപിക്കുന്നു. തന്നിരിക്കുന്ന സൂചികയിലെ ഒരു ഘടകം ഒരു സ്ട്രിംഗിലേക്ക് തിരുകാൻ നിഘണ്ടുക്കൾ നിങ്ങളെ അനുവദിക്കുന്നു. ഇത് ചെയ്യുന്നതിന്, സ്ട്രിംഗിലെ "%(index)s" എന്ന നിർമ്മാണം ഉപയോഗിക്കുക. ഈ സാഹചര്യത്തിൽ, "%(index)s" എന്നതിനുപകരം തന്നിരിക്കുന്ന സൂചികയിലെ നിഘണ്ടു മൂല്യം സൂചികയ്ക്ക് പകരമായിരിക്കും.

>>>അച്ചടിക്കുക "പേര്: %s\nനമ്പർ: %s\nസ്ട്രിംഗ്: %s"% (ente ക്ലാസ്.പേര്, 3 , 3 * "-" )
പേര്: പോറോമെനോസ്
നമ്പർ: 3
സ്ട്രിംഗ്: -
string = """ഈ വാചകം സ്ഥിതിചെയ്യുന്നു
നിരവധി വരികളിൽ """

>>> അച്ചടിക്കുക"ഇത് %(ക്രിയ) ഒരു %(നാമം)s." %("നാമം" : "ടെസ്റ്റ്" , "ക്രിയ" : "ആണ്")
ഇതൊരു പരീക്ഷണമാണ്.

ഓപ്പറേറ്റർമാർ

പ്രസ്താവനകൾ സമയത്ത് എങ്കിൽ, വേണ്ടിമൂവ് ഓപ്പറേറ്റർമാരെ ഉണ്ടാക്കുക. തിരഞ്ഞെടുത്ത പ്രസ്താവനയ്ക്ക് തുല്യമായ ഒന്നുമില്ല, അതിനാൽ നിങ്ങൾ ചെയ്യേണ്ടതായി വരും എങ്കിൽ. ഓപ്പറേറ്ററിൽ വേണ്ടിതാരതമ്യം നടക്കുന്നു വേരിയബിളും പട്ടികയും. ഒരു സംഖ്യ വരെയുള്ള അക്കങ്ങളുടെ ഒരു ലിസ്റ്റ് ലഭിക്കാൻ - ശ്രേണി ഉപയോഗിക്കുക (ഫംഗ്ഷൻ ). ഓപ്പറേറ്റർമാരെ ഉപയോഗിക്കുന്നതിനുള്ള ഒരു ഉദാഹരണം ഇതാ

ശ്രേണിപട്ടിക = ശ്രേണി(10) #പത്ത് അക്കങ്ങളുടെ ഒരു ലിസ്റ്റ് നേടുക (0 മുതൽ 9 വരെ)
>>> അച്ചടിക്കുകറേഞ്ച്ലിസ്റ്റ്
വേണ്ടിശ്രേണിലിസ്റ്റിലെ നമ്പർ: #സംഖ്യ വേരിയബിൾ (ഓരോ തവണയും ഓരോ തവണ വർദ്ധിക്കും) പട്ടികയിൽ ഉൾപ്പെടുത്തിയിരിക്കുന്നിടത്തോളം...
# വേരിയബിൾ ഉൾപ്പെടുത്തിയിട്ടുണ്ടോയെന്ന് പരിശോധിക്കുക
# അക്കങ്ങൾ മുതൽ ഒരു കൂട്ടം സംഖ്യകൾ വരെ(3 , 4 , 7 , 9 )
എങ്കിൽനമ്പർ (3 , 4 , 7 , 9 ): #വേരിയബിൾ നമ്പർ ട്യൂപ്പിലാണെങ്കിൽ (3, 4, 7, 9)...
#ഓപ്പറേഷൻ " ബ്രേക്ക്» നൽകുന്നു
# എപ്പോൾ വേണമെങ്കിലും ലൂപ്പിൽ നിന്ന് പുറത്തുകടക്കുക
ബ്രേക്ക്
വേറെ :
# « തുടരുക"ചുരുളുകൾ"
# ലൂപ്പ്. ഈ ഓപ്പറേഷന് ശേഷം ഇത് ഇവിടെ ആവശ്യമില്ല
# ഏത് സാഹചര്യത്തിലും, പ്രോഗ്രാം ലൂപ്പ് പ്രോസസ്സ് ചെയ്യുന്നതിലേക്ക് തിരികെ പോകുന്നു
തുടരുക
വേറെ :
# « വേറെ» സൂചിപ്പിക്കേണ്ട ആവശ്യമില്ല. വ്യവസ്ഥ പാലിക്കുന്നു
# ലൂപ്പ് തടസ്സപ്പെട്ടില്ലെങ്കിൽ " ബ്രേക്ക്».
കടന്നുപോകുക # ഒന്നും ചെയ്യാനില്ല

എങ്കിൽശ്രേണിലിസ്റ്റ് == 2:
അച്ചടിക്കുക "രണ്ടാമത്തെ ഇനം (ലിസ്റ്റുകൾ 0 അടിസ്ഥാനമാക്കിയുള്ളതാണ്) 2 ആണ്"
എലിഫ്ശ്രേണിലിസ്റ്റ് == 3:
അച്ചടിക്കുക "രണ്ടാമത്തെ ഇനം (ലിസ്റ്റുകൾ 0 അടിസ്ഥാനമാക്കിയുള്ളതാണ്) 3 ആണ്"
വേറെ :
അച്ചടിക്കുക"അറിയില്ല"

സമയത്ത്ശ്രേണിലിസ്റ്റ് == 1:
കടന്നുപോകുക

പ്രവർത്തനങ്ങൾ

ഒരു ഫംഗ്ഷൻ പ്രഖ്യാപിക്കാൻ, ഉപയോഗിക്കുക കീവേഡ് " def» . ഫംഗ്ഷൻ നാമത്തിന് ശേഷം പരാൻതീസിസിൽ ഫംഗ്ഷൻ ആർഗ്യുമെൻ്റുകൾ നൽകിയിരിക്കുന്നു. നിങ്ങൾക്ക് ഓപ്ഷണൽ ആർഗ്യുമെൻ്റുകൾ വ്യക്തമാക്കാൻ കഴിയും, അവയ്ക്ക് ഒരു ഡിഫോൾട്ട് മൂല്യം നൽകുന്നു. ഫംഗ്‌ഷനുകൾക്ക് ട്യൂപ്പിൾസ് തിരികെ നൽകാം, ഈ സാഹചര്യത്തിൽ കോമകളാൽ വേർതിരിച്ച റിട്ടേൺ മൂല്യങ്ങൾ നിങ്ങൾ എഴുതേണ്ടതുണ്ട്. കീവേഡ് " ലാംഡ" പ്രാഥമിക പ്രവർത്തനങ്ങൾ പ്രഖ്യാപിക്കാൻ ഉപയോഗിക്കുന്നു.

# arg2, arg3 എന്നിവ ഓപ്ഷണൽ ആർഗ്യുമെൻ്റുകളാണ്, ഡിഫോൾട്ടായി പ്രഖ്യാപിച്ച മൂല്യം എടുക്കുക,
# ഫംഗ്‌ഷനിലേക്ക് വിളിക്കുമ്പോൾ നിങ്ങൾ അവർക്ക് മറ്റൊരു മൂല്യം നൽകുന്നില്ലെങ്കിൽ.
def myfunction(arg1, arg2 = 100 , arg3 = "ടെസ്റ്റ്" ):
മടങ്ങുക arg3, arg2, arg1
#ആദ്യത്തെ ആർഗ്യുമെൻ്റ് - "ആർഗ്യുമെൻ്റ് 1", രണ്ടാമത്തേത് - ഡിഫോൾട്ടായി, മൂന്നാമത്തേത് - "പേരുള്ള ആർഗ്യുമെൻ്റ്" എന്നിവയുടെ മൂല്യത്തോടെയാണ് ഫംഗ്ഷനെ വിളിക്കുന്നത്.
>>>ret1, ret2, ret3 = myfunction("Argument 1" , arg3 = "Named argument")
# ret1, ret2, ret3 എന്നിവ യഥാക്രമം "നെയിംഡ് ആർഗ്യുമെൻ്റ്", 100, "ആർഗ്യുമെൻ്റ് 1" എന്നീ മൂല്യങ്ങൾ എടുക്കുന്നു
>>> അച്ചടിക്കുക ret1, ret2, ret3
നാമകരണം ചെയ്ത വാദം 100 വാദം 1

# ഇനിപ്പറയുന്ന എൻട്രി തുല്യമാണ് def f(x): മടങ്ങുക x+1
ഫങ്ഷൻവർ = ലാംഡ x:x+1
>>> അച്ചടിക്കുക functionvar(1)
2

ക്ലാസുകൾ

ക്ലാസുകളിലെ ഒന്നിലധികം പാരമ്പര്യങ്ങളിൽ പൈത്തൺ ഭാഷ പരിമിതമാണ്. ഇൻ്റേണൽ വേരിയബിളുകളും ഇൻ്റേണൽ ക്ലാസ് രീതികളും ആരംഭിക്കുന്നത് രണ്ട് അടിവര "__" (ഉദാഹരണത്തിന് "__myprivatevar") ഉപയോഗിച്ചാണ്. ഒരു ക്ലാസ് വേരിയബിളിന് പുറത്ത് നിന്ന് നമുക്ക് ഒരു മൂല്യം നൽകാനും കഴിയും. ഉദാഹരണം:

ക്ലാസ് Ente ക്ലാസ്:
പൊതുവായ = 10
def __init__(സ്വയം):
സ്വയം .myvariable = 3
def myfunction(self , arg1, arg2):
മടങ്ങുകസ്വയം .myvariable

# ഇവിടെ ഞങ്ങൾ എൻ്റെ ക്ലാസ് പ്രഖ്യാപിച്ചു ക്ലാസ്. ക്ലാസുകൾ ആരംഭിക്കുമ്പോൾ __init__ ഫംഗ്‌ഷൻ സ്വയമേവ വിളിക്കപ്പെടുന്നു.
>>> classinstance = എൻ്റെ ക്ലാസ്() # ഞങ്ങൾ ക്ലാസ് ഇനീഷ്യലൈസ് ചെയ്‌തു, ഇനിഷ്യലൈസേഷൻ രീതിയിൽ പറഞ്ഞിരിക്കുന്നതുപോലെ myvariable വേരിയബിളിന് മൂല്യം 3 ഉണ്ട്
>>> #Method myfunction of class My ക്ലാസ് myvariable എന്ന വേരിയബിളിൻ്റെ മൂല്യം നൽകുന്നു
3
# എല്ലാ ക്ലാസുകളിലും പൊതുവായ വേരിയബിൾ പ്രഖ്യാപിച്ചു
>>> classinstance2 = എൻ്റെ ക്ലാസ്()
>>> classinstance.common
10
>>> classinstance2.common
10
# അതുകൊണ്ട് മൈ ക്ലാസിൽ അതിൻ്റെ മൂല്യം മാറ്റിയാൽ ക്ലാസ് മാറും
# എൻ്റെ ക്ലാസ് ആരംഭിച്ച ഒബ്‌ജക്‌റ്റുകളിലെ അതിൻ്റെ മൂല്യങ്ങളും ക്ലാസ്
>>> Myclass.common = 30
>>> classinstance.common
30
>>> classinstance2.common
30
# ഇവിടെ ഞങ്ങൾ ക്ലാസ് വേരിയബിൾ മാറ്റില്ല. ഇതിന് പകരം
# ഞങ്ങൾ അത് ഒരു വസ്തുവിൽ പ്രഖ്യാപിക്കുകയും അതിന് ഒരു പുതിയ മൂല്യം നൽകുകയും ചെയ്യുന്നു
>>> classinstance.common = 10
>>> classinstance.common
10
>>> classinstance2.common
30
>>> Myclass.common = 50
# ഇപ്പോൾ ക്ലാസ് വേരിയബിൾ മാറ്റുന്നത് ബാധിക്കില്ല
ഈ ക്ലാസിലെ # വേരിയബിൾ ഒബ്‌ജക്‌റ്റുകൾ
>>> classinstance.common
10
>>> classinstance2.common
50

# എൻ്റെ ക്ലാസ്സിൻ്റെ പിൻഗാമിയാണ് അടുത്ത ക്ലാസ് ക്ലാസ്
# അതിൻ്റെ ഗുണങ്ങളും രീതികളും അവകാശമാക്കി, ആർക്കാണ് ക്ലാസ് എടുക്കാൻ കഴിയുക
# നിരവധി ക്ലാസുകളിൽ നിന്ന് അവകാശം നേടുക, ഈ സാഹചര്യത്തിൽ പ്രവേശനം
# ഇതുപോലെ: ക്ലാസ്മറ്റ് ക്ലാസ്(Myclass1, Myclass2, MyclassN)
ക്ലാസ്മറ്റ് ക്ലാസ്(മൈക്ലാസ്):
def __init__(സ്വയം, arg1):
സ്വയം .myvariable = 3
അച്ചടിക്കുക arg1

>>> ക്ലാസ് ഇൻസ്‌റ്റൻസ് = മറ്റ് ക്ലാസ്("ഹലോ")
ഹലോ
>>> classinstance.myfunction(1 , 2 )
3
# ഈ ക്ലാസിന് പ്രോപ്പർട്ടി ടെസ്റ്റ് ഇല്ല, പക്ഷേ ഞങ്ങൾക്ക് കഴിയും
# ഒരു ഒബ്ജക്റ്റിനായി അത്തരമൊരു വേരിയബിൾ പ്രഖ്യാപിക്കുക. മാത്രമല്ല
# ഈ വേരിയബിൾ ഒരു അംഗം മാത്രമായിരിക്കും ക്ലാസ്ഉദാഹരണം.
>>> classinstance.test = 10
>>> classinstance.test
10

ഒഴിവാക്കലുകൾ

പൈത്തണിലെ ഒഴിവാക്കലുകൾക്ക് ഒരു ഘടനയുണ്ട് ശ്രമിക്കുക-ഒഴികെ [ഒഴികെഅയൺനാമം]:

defചില പ്രവർത്തനം ():
ശ്രമിക്കുക :
# പൂജ്യം കൊണ്ട് വിഭജിക്കുന്നത് ഒരു പിശകിന് കാരണമാകുന്നു
10 / 0
ഒഴികെസീറോ ഡിവിഷൻ പിശക്:
# എന്നാൽ പ്രോഗ്രാം "ഒരു നിയമവിരുദ്ധ പ്രവർത്തനം നടത്തില്ല"
# കൂടാതെ "ZeroDivisionError" പിശകിന് അനുയോജ്യമായ ഒഴിവാക്കൽ ബ്ലോക്ക് കൈകാര്യം ചെയ്യുന്നു
അച്ചടിക്കുക"ശ്ശോ, അസാധുവാണ്."

>>>fn ഒഴികെ()
ക്ഷമിക്കണം, അസാധുവാണ്.

ഇറക്കുമതി ചെയ്യുക

നടപടിക്രമം ഉപയോഗിച്ച് ബാഹ്യ ലൈബ്രറികൾ ബന്ധിപ്പിക്കാൻ കഴിയും " ഇറക്കുമതി", കണക്ട് ചെയ്തിരിക്കുന്ന ലൈബ്രറിയുടെ പേര് എവിടെയാണ്. "" എന്ന കമാൻഡും നിങ്ങൾക്ക് ഉപയോഗിക്കാം. നിന്ന് ഇറക്കുമതി" അതിനാൽ നിങ്ങൾക്ക് ലൈബ്രറിയിൽ നിന്ന് ഒരു ഫംഗ്ഷൻ ഉപയോഗിക്കാം

ഇറക്കുമതിക്രമരഹിതമായ # "റാൻഡം" ലൈബ്രറി ഇറക്കുമതി ചെയ്യുക
നിന്ന്സമയം ഇറക്കുമതിക്ലോക്ക് #അതേ സമയം "സമയം" ലൈബ്രറിയിൽ നിന്ന് "ക്ലോക്ക്" പ്രവർത്തിക്കുന്നു

ക്രമരഹിതം = ക്രമരഹിതം .randint(1 , 100 )
>>> അച്ചടിക്കുകക്രമരഹിതമായ
64

ഫയൽ സിസ്റ്റത്തിൽ പ്രവർത്തിക്കുന്നു

പൈത്തണിന് നിരവധി ബിൽറ്റ്-ഇൻ ലൈബ്രറികളുണ്ട്. ഈ ഉദാഹരണത്തിൽ, ഒരു ബൈനറി ഫയലിൽ ഒരു ലിസ്റ്റ് ഘടന സംരക്ഷിക്കാൻ ഞങ്ങൾ ശ്രമിക്കും, അത് വായിച്ച് ഒരു ടെക്സ്റ്റ് ഫയലിൽ സ്ട്രിംഗ് സംരക്ഷിക്കുക. ഡാറ്റാ ഘടന രൂപാന്തരപ്പെടുത്തുന്നതിന് ഞങ്ങൾ സാധാരണ ലൈബ്രറി "അച്ചാർ" ഉപയോഗിക്കും

ഇറക്കുമതിഉപ്പിലിട്ടത്
mylist = ["ഇത്" , "ആണ്" , 4 , 13327 ]
# എഴുതുന്നതിനായി C:\binary.dat ഫയൽ തുറക്കുക. "r" ചിഹ്നം
# പ്രത്യേക പ്രതീകങ്ങൾ മാറ്റിസ്ഥാപിക്കുന്നത് തടയുന്നു (\n, \t, \b, മുതലായവ).
myfile = ഫയൽ (r"C:\binary.dat" , "w")
pickle .dump(mylist, myfile)
myfile.close()

Myfile = ഫയൽ (r"C:\text.txt" , "w")
myfile.write("ഇതൊരു സാമ്പിൾ സ്ട്രിംഗ് ആണ്")
myfile.close()

Myfile = ഫയൽ (r"C:\text.txt")
>>> അച്ചടിക്കുക myfile.read()
"ഇതൊരു സാമ്പിൾ സ്ട്രിംഗ് ആണ്"
myfile.close()

# വായിക്കാൻ ഫയൽ തുറക്കുക
myfile = ഫയൽ (r"C:\binary.dat")
loadedlist = അച്ചാർ .load(myfile)
myfile.close()
>>> അച്ചടിക്കുകലോഡ് ചെയ്ത പട്ടിക
["ഇത്" , "ആണ്" , 4 , 13327 ]

പ്രത്യേകതകൾ

• വ്യവസ്ഥകൾ സംയോജിപ്പിക്കാം. 1 < a < 3 выполняется тогда, когда а больше 1, но меньше 3.
• പ്രവർത്തനം ഉപയോഗിക്കുക " ഡെൽ"ലേക്ക് വ്യക്തമായ വേരിയബിളുകൾ അല്ലെങ്കിൽ അറേ ഘടകങ്ങൾ.
• പൈത്തൺ മികച്ച അവസരങ്ങൾ വാഗ്ദാനം ചെയ്യുന്നു ലിസ്റ്റുകളുമായി പ്രവർത്തിക്കുന്നു. നിങ്ങൾക്ക് ലിസ്റ്റ് ഘടന ഡിക്ലറേഷൻ ഓപ്പറേറ്റർമാർ ഉപയോഗിക്കാം. ഓപ്പറേറ്റർ വേണ്ടിഒരു നിർദ്ദിഷ്ട ശ്രേണിയിൽ ലിസ്റ്റ് ഘടകങ്ങൾ വ്യക്തമാക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു, കൂടാതെ എങ്കിൽ- വ്യവസ്ഥ അനുസരിച്ച് ഘടകങ്ങൾ തിരഞ്ഞെടുക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു.

>>> lst1 =
>>> lst2 =
>>> അച്ചടിക്കുക
>>> അച്ചടിക്കുക
# എന്നിരുന്നാലും "ഏതെങ്കിലും" ഓപ്പറേറ്റർ ശരിയാണെന്ന് നൽകുന്നു
# അതിൽ ഉൾപ്പെടുത്തിയിരിക്കുന്ന വ്യവസ്ഥകളിലൊന്ന് തൃപ്തികരമാണെങ്കിൽ.
>>> ഏതെങ്കിലും (i % 3 വേണ്ടിഞാൻ ഇൻ)
സത്യം
# ഇനിപ്പറയുന്ന നടപടിക്രമം നമ്പർ കണക്കാക്കുന്നു
ലിസ്റ്റിലെ # പൊരുത്തപ്പെടുന്ന ഘടകങ്ങൾ
>>> തുക (1 വേണ്ടിഞാൻ അകത്ത് എങ്കിൽഞാൻ == 3)
3
>>> ഡെൽ lst1
>>> അച്ചടിക്കുക lst1
>>> ഡെൽ lst1

• ഗ്ലോബൽ വേരിയബിളുകൾഫംഗ്‌ഷനുകൾക്ക് പുറത്ത് പ്രഖ്യാപിക്കുകയും പ്രഖ്യാപനങ്ങളൊന്നും കൂടാതെ വായിക്കുകയും ചെയ്യാം. എന്നാൽ നിങ്ങൾക്ക് ഒരു ഫംഗ്ഷനിൽ നിന്ന് ഒരു ആഗോള വേരിയബിളിൻ്റെ മൂല്യം മാറ്റണമെങ്കിൽ, ഫംഗ്ഷൻ്റെ തുടക്കത്തിൽ കീവേഡ് ഉപയോഗിച്ച് നിങ്ങൾ അത് പ്രഖ്യാപിക്കേണ്ടതുണ്ട് " ആഗോള"നിങ്ങൾ ഇത് ചെയ്യുന്നില്ലെങ്കിൽ, ആ ഫംഗ്ഷനിലേക്ക് മാത്രം ആക്സസ് ചെയ്യാൻ കഴിയുന്ന ഒരു വേരിയബിൾ പൈത്തൺ പ്രഖ്യാപിക്കും.

നമ്പർ = 5

def myfunc():
# ഔട്ട്പുട്ടുകൾ 5
അച്ചടിക്കുകനമ്പർ

defമറ്റൊരു ഫങ്ക് ():
# ആഗോള വേരിയബിൾ ആയതിനാൽ ഇത് ഒരു അപവാദം നൽകുന്നു
# ഒരു ചടങ്ങിൽ നിന്ന് വിളിച്ചിട്ടില്ല. ഈ കേസിൽ പൈത്തൺ സൃഷ്ടിക്കുന്നു
ഈ ഫംഗ്‌ഷനിൽ ഒരേ പേരിലുള്ള # വേരിയബിൾ ആക്‌സസ് ചെയ്യാവുന്നതാണ്
# ഈ ഫംഗ്‌ഷൻ്റെ ഓപ്പറേറ്റർമാർക്ക് മാത്രം.
അച്ചടിക്കുകനമ്പർ
നമ്പർ = 3

def yetanotherfunc():
ആഗോളനമ്പർ
# ഈ ഫംഗ്‌ഷനിൽ നിന്ന് മാത്രമേ വേരിയബിളിൻ്റെ മൂല്യം മാറുകയുള്ളൂ.
നമ്പർ = 3

ഉപസംഹാരം

തീർച്ചയായും, ഈ ലേഖനം പൈത്തണിൻ്റെ എല്ലാ സവിശേഷതകളും വിവരിക്കുന്നില്ല. ഈ പ്രോഗ്രാമിംഗ് ഭാഷ പഠിക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നുവെങ്കിൽ ഈ ലേഖനം നിങ്ങളെ സഹായിക്കുമെന്ന് ഞാൻ പ്രതീക്ഷിക്കുന്നു.

പൈത്തണിൻ്റെ പ്രയോജനങ്ങൾ

• പൈത്തണിൽ എഴുതിയ പ്രോഗ്രാമുകളുടെ എക്സിക്യൂഷൻ വേഗത വളരെ കൂടുതലാണ്. പ്രധാന പൈത്തൺ ലൈബ്രറികളാണെന്നതാണ് ഇതിന് കാരണം
  C++ ൽ എഴുതിയവയും മറ്റ് ഉയർന്ന തലത്തിലുള്ള ഭാഷകളേക്കാൾ ടാസ്‌ക്കുകൾ പൂർത്തിയാക്കാൻ കുറച്ച് സമയമെടുക്കുകയും ചെയ്യുന്നു.
• ഇക്കാരണത്താൽ, നിങ്ങൾക്ക് നിങ്ങളുടെ സ്വന്തം പൈത്തൺ മൊഡ്യൂളുകൾ സി അല്ലെങ്കിൽ സി ++ ൽ എഴുതാം
• സ്റ്റാൻഡേർഡ് പൈത്തൺ ലൈബ്രറികളിൽ ഇമെയിൽ, പ്രോട്ടോക്കോളുകൾ എന്നിവയിൽ പ്രവർത്തിക്കുന്നതിനുള്ള ഉപകരണങ്ങൾ നിങ്ങൾക്ക് കണ്ടെത്താനാകും
  ഇൻ്റർനെറ്റ്, FTP, HTTP, ഡാറ്റാബേസുകൾ മുതലായവ.
• പൈത്തൺ ഉപയോഗിച്ച് എഴുതിയ സ്ക്രിപ്റ്റുകൾ മിക്ക ആധുനിക ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങളിലും പ്രവർത്തിക്കുന്നു. ഈ പോർട്ടബിലിറ്റി പൈത്തണിനെ വിശാലമായ ആപ്ലിക്കേഷനുകളിൽ ഉപയോഗിക്കാൻ അനുവദിക്കുന്നു.
• ഓഫീസ് പ്രോഗ്രാമുകൾ, വെബ് ആപ്ലിക്കേഷനുകൾ, ജിയുഐ ആപ്ലിക്കേഷനുകൾ എന്നിങ്ങനെയുള്ള ഏത് പ്രോഗ്രാമിംഗ് സൊല്യൂഷനുകൾക്കും പൈത്തൺ അനുയോജ്യമാണ്.
• ലോകമെമ്പാടുമുള്ള ആയിരക്കണക്കിന് ഉത്സാഹികൾ പൈത്തണിൻ്റെ വികസനത്തിനായി പ്രവർത്തിച്ചു. സ്റ്റാൻഡേർഡ് ലൈബ്രറികളിലെ ആധുനിക സാങ്കേതികവിദ്യകൾക്കുള്ള പിന്തുണ പൈത്തൺ എല്ലാവർക്കുമായി തുറന്നിരിക്കുന്നു എന്ന വസ്തുതയ്ക്ക് കാരണമാകാം.

ടാഗുകൾ:

• പൈത്തൺ
• പ്രോഗ്രാമിംഗ്
• പാഠം

ഭാഷ പോലെ തന്നെ പൈത്തണിൻ്റെ വാക്യഘടനയും വളരെ ലളിതമാണ്.

വാക്യഘടന

വരിയുടെ അവസാനം പ്രസ്താവനയുടെ അവസാനമാണ് (അർദ്ധവിരാമം ആവശ്യമില്ല).

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

പൈത്തണിലെ നെസ്റ്റഡ് സ്റ്റേറ്റ്‌മെൻ്റുകൾ ഒരേ പാറ്റേൺ പിന്തുടരുന്നു, പ്രധാന പ്രസ്താവന കോളണിൽ അവസാനിക്കുന്നു, തുടർന്ന് കോഡിൻ്റെ ഒരു നെസ്റ്റഡ് ബ്ലോക്ക്, സാധാരണയായി പ്രധാന പ്രസ്താവന ലൈനിന് താഴെ ഇൻഡൻ്റ് ചെയ്യുന്നു.

പ്രധാന നിർദ്ദേശം: നെസ്റ്റഡ് ഇൻസ്ട്രക്ഷൻ ബ്ലോക്ക്

നിരവധി പ്രത്യേക കേസുകൾ

• ചിലപ്പോൾ അർദ്ധവിരാമങ്ങളാൽ വേർതിരിച്ച് ഒരു വരിയിൽ നിരവധി നിർദ്ദേശങ്ങൾ എഴുതാൻ കഴിയും:

  a = 1 ; b = 2; പ്രിൻ്റ് (എ, ബി)

  എന്നാൽ ഇത് പലപ്പോഴും ചെയ്യരുത്! വായനാക്ഷമത ഓർക്കുക. ഇതിലും നല്ലത്, അത് ഒരിക്കലും ചെയ്യരുത്.

  ഒന്നിലധികം വരികളിൽ ഒരു നിർദ്ദേശം എഴുതുന്നത് സ്വീകാര്യമാണ്. ഒരു ജോടി വൃത്താകൃതിയിലുള്ളതോ ചതുരാകൃതിയിലുള്ളതോ ചുരുണ്ടതോ ആയ ബ്രാക്കറ്റുകളിൽ ഇത് ഉൾപ്പെടുത്തിയാൽ മതി:

  എങ്കിൽ (a == 1 ഉം b == 2 ഉം c == 3 ഉം d == 4 ഉം): # കോളനിനെക്കുറിച്ച് മറക്കരുത്പ്രിൻ്റ് ("സ്പാം" * 3)

• സംയുക്ത നിർദ്ദേശത്തിൻ്റെ ബോഡിയിൽ സംയുക്ത നിർദ്ദേശങ്ങൾ അടങ്ങിയിട്ടില്ലെങ്കിൽ, പ്രധാന നിർദ്ദേശത്തിൻ്റെ ബോഡിയുടെ അതേ വരിയിൽ ഒരു സംയുക്ത നിർദ്ദേശത്തിൻ്റെ ബോഡി ദൃശ്യമാകാം. ശരി, നിങ്ങൾക്ക് മനസ്സിലായെന്ന് ഞാൻ കരുതുന്നു :). ഇതിലും നല്ല ഒരു ഉദാഹരണം പറയാം.

കുറിച്ച് പൈത്തൺ(ചിലർ "പൈത്തൺ" എന്ന് പറയുമെങ്കിലും, "പൈത്തൺ" എന്ന് നന്നായി ഉച്ചരിക്കുന്നു) - ഈ പഠനത്തിൻ്റെ വിഷയം, ഈ പ്രോഗ്രാമിംഗ് ഭാഷയുടെ സ്രഷ്ടാവ്, ഡച്ച്മാൻ ഗൈഡോ വാൻ റോസ്സം ആണ് ഏറ്റവും നന്നായി പറഞ്ഞത്:

"പൈത്തൺ ഒരു വ്യാഖ്യാനിച്ച, ഒബ്ജക്റ്റ്-ഓറിയൻ്റഡ്, ഡൈനാമിക് സെമാൻ്റിക്‌സുള്ള ഉയർന്ന-ലെവൽ പ്രോഗ്രാമിംഗ് ഭാഷയാണ്. ബിൽറ്റ്-ഇൻ ഉയർന്ന തലത്തിലുള്ള ഡാറ്റാ ഘടനകൾ ഡൈനാമിക് ടൈപ്പിംഗ്ബൈൻഡിംഗ് ദ്രുത ആപ്ലിക്കേഷൻ വികസനത്തിന് (RAD, റാപ്പിഡ് ആപ്ലിക്കേഷൻ ഡെവലപ്‌മെൻ്റ്) ഭാഷയെ ആകർഷകമാക്കുന്നു. സോഫ്റ്റ്‌വെയർ ഘടകങ്ങളുമായി ആശയവിനിമയം നടത്തുന്നതിനുള്ള ഒരു സ്ക്രിപ്റ്റിംഗ് ഭാഷയായും ഇത് ഉപയോഗിക്കാം. പൈത്തൺ വാക്യഘടന പഠിക്കാൻ എളുപ്പമാണ് കൂടാതെ കോഡ് റീഡബിലിറ്റിക്ക് ഊന്നൽ നൽകുന്നു, ഇത് സോഫ്റ്റ്‌വെയർ പരിപാലന ചെലവ് കുറയ്ക്കുന്നു. പൈത്തൺ മൊഡ്യൂളുകളും പാക്കേജുകളും പിന്തുണയ്ക്കുന്നു, മോഡുലാരിറ്റിയും കോഡ് പുനരുപയോഗവും പ്രോത്സാഹിപ്പിക്കുന്നു. പൈത്തൺ ഇൻ്റർപ്രെറ്ററും വലിയ സ്റ്റാൻഡേർഡ് ലൈബ്രറിയും എല്ലാ പ്രധാന പ്ലാറ്റ്‌ഫോമുകൾക്കും ഉറവിടമായും എക്‌സിക്യൂട്ടബിൾ കോഡായും സൗജന്യമായി ലഭ്യമാണ്, അവ സ്വതന്ത്രമായി പുനർവിതരണം ചെയ്യാനും കഴിയും.

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

സോഫ്‌റ്റ്‌വെയർ ഉൽപ്പന്നങ്ങൾ (അവയുടെ പ്രോട്ടോടൈപ്പുകൾ) സൃഷ്‌ടിക്കുന്നതിനുള്ള ഒരു സമ്പൂർണ സാങ്കേതികവിദ്യയായി പൈത്തണിനെ നമുക്ക് കണക്കാക്കാം. ഇത് മിക്കവാറും എല്ലാ ആധുനിക പ്ലാറ്റ്‌ഫോമുകളിലും (32-ബിറ്റ്, 64-ബിറ്റ്) ഒരു സി കമ്പൈലറിലും ജാവ പ്ലാറ്റ്‌ഫോമിലും ലഭ്യമാണ്.

C/C++, Java, Visual Basic, C# അല്ലാതെ മറ്റൊന്നിനും സോഫ്‌റ്റ്‌വെയർ വ്യവസായത്തിൽ ഇടമില്ലെന്ന് തോന്നാം. എന്നിരുന്നാലും, അങ്ങനെയല്ല. ഒരുപക്ഷേ, ഈ പ്രഭാഷണങ്ങൾക്കും പ്രായോഗിക വ്യായാമങ്ങൾക്കും നന്ദി, പൈത്തൺ പുതിയ അനുയായികളെ നേടും, അവർക്ക് അത് ഒഴിച്ചുകൂടാനാവാത്ത ഉപകരണമായി മാറും.

ഭാഷയെ എങ്ങനെ വിവരിക്കാം?

ഈ പ്രഭാഷണം പൈത്തണിനെ വ്യവസ്ഥാപിതമായി വിവരിക്കാൻ ലക്ഷ്യമിടുന്നില്ല; അതിനായി ഒരു യഥാർത്ഥ റഫറൻസ് ഗൈഡ് ഉണ്ട്. ഒരേസമയം നിരവധി വശങ്ങളിൽ നിന്ന് ഭാഷ പരിഗണിക്കാൻ ഇവിടെ നിർദ്ദേശിക്കപ്പെട്ടിരിക്കുന്നു, ഇത് കർശനമായ അക്കാദമിക് സമീപനത്തേക്കാൾ യഥാർത്ഥ പ്രോഗ്രാമിംഗുമായി വേഗത്തിൽ പരിചയപ്പെടാൻ നിങ്ങളെ അനുവദിക്കുന്ന ഒരു കൂട്ടം ഉദാഹരണങ്ങളാൽ കൈവരിക്കാനാകും.

എന്നിരുന്നാലും, ഭാഷയെ വിവരിക്കുന്നതിനുള്ള ശരിയായ സമീപനം ശ്രദ്ധിക്കേണ്ടതാണ്. ഒരു പ്രോഗ്രാം സൃഷ്ടിക്കുന്നത് എല്ലായ്പ്പോഴും ഒരു ആശയവിനിമയമാണ്, അതിൽ പ്രോഗ്രാമർ കമ്പ്യൂട്ടറിലേക്ക് പ്രവർത്തനങ്ങൾ നടത്തുന്നതിന് ആവശ്യമായ വിവരങ്ങൾ കൈമാറുന്നു. പ്രോഗ്രാമർ ഈ പ്രവർത്തനങ്ങൾ മനസ്സിലാക്കുന്ന രീതി (അതായത്, "അർത്ഥം") വിളിക്കാം അർത്ഥശാസ്ത്രം. ഈ അർത്ഥം അറിയിക്കുന്നതിനുള്ള മാർഗ്ഗം വാക്യഘടനപ്രോഗ്രാമിംഗ് ഭാഷ. ശരി, പാസാക്കിയതിനെ അടിസ്ഥാനമാക്കി വ്യാഖ്യാതാവ് ചെയ്യുന്നതിനെ സാധാരണയായി വിളിക്കുന്നു പ്രായോഗികത. ഒരു പ്രോഗ്രാം എഴുതുമ്പോൾ, ഈ ശൃംഖലയിൽ പരാജയങ്ങളൊന്നുമില്ല എന്നത് വളരെ പ്രധാനമാണ്.

വാക്യഘടന പൂർണ്ണമായും ഔപചാരികമായ ഒരു ഭാഗമാണ്: ഇത് വിവരിക്കാം ഔപചാരിക ഭാഷവാക്യഘടന ഡയഗ്രമുകൾ (അതാണ് റഫറൻസ് മാനുവലുകൾ ചെയ്യുന്നത്). പ്രായോഗികതയുടെ ആവിഷ്കാരം ഭാഷാ വ്യാഖ്യാതാവ് തന്നെയാണ്. വാക്യഘടനയ്ക്ക് അനുസൃതമായി രേഖപ്പെടുത്തിയ “സന്ദേശം” വായിക്കുകയും അതിൽ ഉൾച്ചേർത്ത അൽഗോരിതം അനുസരിച്ച് പ്രവർത്തനങ്ങളാക്കി മാറ്റുകയും ചെയ്യുന്നത് അവനാണ്. ഒരേയൊരു അനൗപചാരിക ഘടകം അർത്ഥശാസ്ത്രമായി അവശേഷിക്കുന്നു. ഔപചാരിക വിവരണത്തിലേക്ക് അർത്ഥം വിവർത്തനം ചെയ്യുന്നതിലാണ് പ്രോഗ്രാമിംഗിൻ്റെ ഏറ്റവും വലിയ ബുദ്ധിമുട്ട്. പൈത്തണിൻ്റെ വാക്യഘടനയ്ക്ക് ശക്തമായ സവിശേഷതകളുണ്ട്, അത് ഒരു പ്രശ്നത്തെക്കുറിച്ചുള്ള പ്രോഗ്രാമറുടെ ഗ്രാഹ്യത്തെ വ്യാഖ്യാതാവിൻ്റെ "ധാരണ" യിലേക്ക് അടുപ്പിക്കാൻ സഹായിക്കുന്നു. പൈത്തണിൻ്റെ ആന്തരിക ഘടന അന്തിമ പ്രഭാഷണങ്ങളിലൊന്നിൽ ചർച്ചചെയ്യും.

പൈത്തൺ ഭാഷയുടെ ചരിത്രം

1991-ൽ ഗൈഡോ വാൻ റോസ്സം വിതരണം ചെയ്ത അമീബ ഒഎസിൽ പ്രവർത്തിക്കുമ്പോഴാണ് പൈത്തൺ ആരംഭിച്ചത്. സിസ്റ്റം കോളുകൾക്ക് പിന്തുണ നൽകുന്ന ഒരു വിപുലീകരിക്കാവുന്ന ഭാഷ അദ്ദേഹത്തിന് ആവശ്യമായിരുന്നു. എബിസി, മോഡുല-3 എന്നിവ അടിസ്ഥാനമായി എടുത്തു. ബിബിസി കോമഡി പരമ്പരയായ മോണ്ടി പൈത്തണിൻ്റെ ഫ്ലയിംഗ് സർക്കസിൻ്റെ ബഹുമാനാർത്ഥം അദ്ദേഹം പൈത്തൺ ഒരു പേരായി തിരഞ്ഞെടുത്തു, അല്ലാതെ പാമ്പിൻ്റെ പേരിന് ശേഷമല്ല. അതിനുശേഷം, ഗൈഡോ പ്രവർത്തിച്ചിരുന്ന സംഘടനകളുടെ പിന്തുണയോടെ പൈത്തൺ വികസിപ്പിച്ചെടുത്തു. സ്രഷ്‌ടാക്കളുടെ ടീം മാത്രമല്ല, ലോകമെമ്പാടുമുള്ള പ്രോഗ്രാമർമാരുടെ ഒരു മുഴുവൻ കമ്മ്യൂണിറ്റിയും പ്രവർത്തിക്കുമ്പോൾ, ഭാഷ പ്രത്യേകിച്ചും സജീവമായി മെച്ചപ്പെടുത്തിക്കൊണ്ടിരിക്കുകയാണ്. എന്നിരുന്നാലും, ഭാഷാ വികസനത്തിൻ്റെ ദിശയെക്കുറിച്ചുള്ള അവസാന വാക്ക് ഗൈഡോ വാൻ റോസ്സത്തിൻ്റെ പക്കലുണ്ട്.