ഉള്ളടക്ക പട്ടിക[മറയ്ക്കുക][കാണിക്കുക]
ഈ പ്രഭാഷണം പൈത്തണിലെ ട്യൂപ്പിൾ എന്നറിയപ്പെടുന്ന മറ്റൊരു അവശ്യ ഘടനയെക്കുറിച്ചാണ്.
ടുപ്പിൾസ്
Tuples ലിസ്റ്റുകൾക്ക് സമാനമാണ്, അതിനാൽ ഇനങ്ങളുടെ ഒരു ലിസ്റ്റ് സംഭരിക്കുന്നതിന് നമുക്ക് അവ ഉപയോഗിക്കാം. എന്നാൽ ലിസ്റ്റുകളിൽ നിന്ന് വ്യത്യസ്തമായി, ഞങ്ങൾക്ക് അവ പരിഷ്ക്കരിക്കാനോ പുതിയ ഇനങ്ങൾ ചേർക്കാനോ നിലവിലുള്ള ഇനങ്ങൾ നീക്കംചെയ്യാനോ കഴിയില്ല. ട്യൂപ്പിൾസ് മാറ്റമില്ലാത്തതാണെന്ന് നമുക്ക് പറയാം.
ഞാൻ നിനക്ക് കാണിച്ചു തരട്ടെ. ലിസ്റ്റുകളിലെ ചതുര ബ്രാക്കറ്റുകൾക്ക് പകരം പരാൻതീസിസ് ഉപയോഗിച്ചാണ് ട്യൂപ്പിളുകളെ തിരിച്ചറിയുന്നത്.
numbers = (4, 1, 7, 5, 0, 9)
ഇപ്പോൾ, ഞങ്ങൾ tuples-നുള്ള രീതികളുടെ ലിസ്റ്റ് പുറത്തെടുത്താൽ, ഞങ്ങളുടെ പക്കൽ append അല്ലെങ്കിൽ insert രീതികൾ ഇല്ലെന്ന് നിങ്ങൾക്ക് കാണാൻ കഴിയും, അതിനാൽ ഈ tuple-ലേക്ക് പുതിയ ഇനങ്ങൾ ചേർക്കാൻ കഴിയില്ല. ഞങ്ങൾക്ക് രണ്ട് രീതികൾ മാത്രമേയുള്ളൂ: എണ്ണവും സൂചികയും.
ഒരു ഇനത്തിന്റെ സംഭവങ്ങളുടെ എണ്ണം കണക്കാക്കാൻ ഞങ്ങൾ "എണ്ണം" ഉപയോഗിക്കുന്നു. ഒരു ഇനത്തിന്റെ ആദ്യ സംഭവത്തിന്റെ സൂചിക കണ്ടെത്താൻ "സൂചിക" ഉപയോഗിക്കുന്നു. അതിനാൽ, ഞങ്ങൾക്ക് ഒരു ട്യൂപ്പിലിനെക്കുറിച്ചുള്ള വിവരങ്ങൾ മാത്രമേ ലഭിക്കൂ, ഞങ്ങൾക്ക് അത് മാറ്റാൻ കഴിയില്ല. വഴിയിൽ, നിങ്ങൾ ഇവിടെ കാണുന്ന ഈ മറ്റ് രീതികൾ, രണ്ട് അടിവരകൾ ഉപയോഗിച്ച് ആരംഭിക്കുക.
ഞങ്ങൾ ഇവയെ മാന്ത്രിക രീതികൾ എന്ന് വിളിക്കുന്നു. അവ കൂടുതൽ വിപുലമായ വിഷയമാണ്, ഞങ്ങളുടെ ഭാവി പരമ്പരകളിൽ ഞങ്ങൾ അവ സ്പർശിക്കും.
മാറ്റമില്ലാത്തത് കൂടാതെ, ഒരു ലിസ്റ്റിന്റെ മിക്ക സവിശേഷതകളും ട്യൂപ്പിൾസ് പങ്കിടുന്നു.
പ്രായോഗികമായി പറഞ്ഞാൽ, മിക്ക സമയത്തും നിങ്ങൾ ലിസ്റ്റുകൾ ഉപയോഗിക്കും, പക്ഷേ ട്യൂപ്പിളുകളും ഉപയോഗപ്രദമാണ്. നിങ്ങൾക്ക് ഇനങ്ങളുടെ ഒരു ലിസ്റ്റ് സൃഷ്ടിക്കാനും നിങ്ങളുടെ പ്രോഗ്രാമിൽ ഒരിടത്തും ആ ലിസ്റ്റ് അബദ്ധവശാൽ പരിഷ്ക്കരിക്കുന്നില്ലെന്ന് ഉറപ്പാക്കാനും ആഗ്രഹിക്കുന്നുവെങ്കിൽ, ഒരു ട്യൂപ്പിൾ ഉപയോഗിക്കുന്നതാണ് നല്ലത്.
പായ്ക്ക് ചെയ്യുന്നു
ഈ വിഭാഗത്തിൽ, ഞാൻ നിങ്ങൾക്ക് ഒരു ശക്തമായ സവിശേഷത കാണിക്കാൻ പോകുന്നു, ഞങ്ങൾ പൈത്തണിൽ അൺപാക്കിംഗ് എന്ന് വിളിക്കുന്നു.
നമുക്ക് ഒരു ട്യൂപ്പിൾ "കോർഡിനേറ്റ്" നിർവചിക്കാം
coordinate = (1, 2, 3)
ഇപ്പോൾ, ഇവ 'x', 'y', 'z' എന്നിവയുടെ കോർഡിനേറ്റുകളാണെന്ന് സങ്കൽപ്പിക്കുക. ഇനി നമുക്ക് പറയാം, ഈ മൂല്യങ്ങൾ നേടാനും അവ ഞങ്ങളുടെ പ്രോഗ്രാമിൽ കുറച്ച് സങ്കീർണ്ണമായ എക്സ്പ്രഷനുകളിൽ ഉപയോഗിക്കാനും ആഗ്രഹിക്കുന്നു. ഒരുപക്ഷേ, ഒരു വലിയ സങ്കീർണ്ണ ഫോർമുലയുടെ ഭാഗമായി അവയെ ഉൾപ്പെടുത്താൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നു.
അതിനാൽ, ഞങ്ങൾ ഒരുമിച്ച് ഇതുപോലെ കോഡ് എഴുതേണ്ടതുണ്ട്:
coordinate[0] * coordinate[1] * coordinate[2]
ഈ കോഡ് ലൈൻ എല്ലാ കോർഡിനേറ്റുകളും വർദ്ധിപ്പിക്കും, പക്ഷേ നമ്മുടെ കോഡ് ഇതുപോലെ എഴുതുന്നത് കാര്യക്ഷമമല്ല. ആദ്യം, നമുക്ക് ഒരു മികച്ച സമീപനം ഉപയോഗിക്കുകയും ഈ കോർഡിനേറ്റുകൾ പ്രത്യേക വേരിയബിളുകളിൽ സൂക്ഷിക്കുകയും ചെയ്യാം.
x = coordinate[0]
y = coordinate[1]
z = coordinate[2]
അതാണ് നല്ലത്. ശരിയാണോ? അതുകൊണ്ട് ഇതുവരെ പുതിയതായി ഒന്നുമില്ല. ഇപ്പോൾ, അൺപാക്കിംഗ് എന്ന ശക്തമായ ഒരു ഫീച്ചർ ഞാൻ നിങ്ങൾക്ക് കാണിച്ചുതരാം, അതുപയോഗിച്ച്, വളരെ കുറഞ്ഞ കോഡ് ഉപയോഗിച്ച് ഞങ്ങൾക്ക് അതേ ഫലം നേടാനാകും.
x, y, z, = coordinate
ഇപ്പോൾ, ഈ ഒറ്റ വരി കോഡ് മുകളിൽ എഴുതിയിരിക്കുന്ന മൂന്ന് വരി കോഡിന് തുല്യമാണ്. ഇത് എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്ന് ഞാൻ നിങ്ങളോട് വിശദീകരിക്കാം.
പൈത്തൺ ഇന്റർപ്രെറ്റർ ഈ പ്രസ്താവന കാണുമ്പോൾ, അത് ഈ ട്യൂപ്പിളിലെ ആദ്യ ഇനം നേടുകയും അത് വേരിയബിളിലേക്ക് നൽകുകയും ചെയ്യും. അതുപോലെ, രണ്ടാമത്തെയും മൂന്നാമത്തെയും ഇനങ്ങൾ വേരിയബിളുകൾക്ക് നൽകപ്പെടും. ഇത് ചെയ്യുന്നതിലൂടെ, ഞങ്ങൾ ഈ ട്യൂപ്പിൾ 3 വേരിയബിളുകളായി അൺപാക്ക് ചെയ്യുന്നു. നമുക്ക് നമ്മുടെ ഔട്ട്പുട്ട് പരിശോധിക്കാം.
ലിസ്റ്റുകൾ ഉപയോഗിച്ച് അൺപാക്ക് ചെയ്യാനും കഴിയും.
നിഘണ്ടുക്കൾ
പൈത്തണിലെ നിഘണ്ടുക്കളെക്കുറിച്ചാണ് നമ്മൾ പഠിക്കാൻ പോകുന്നത്. കീ-വാല്യൂ ജോഡികളായി വരുന്ന വിവരങ്ങൾ സംഭരിക്കാൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്ന സാഹചര്യങ്ങളിൽ ഞങ്ങൾ നിഘണ്ടുക്കൾ ഉപയോഗിക്കുന്നു.
ഇതാ ഒരു ഉദാഹരണം. പേര്, ഇമെയിൽ, ഫോൺ നമ്പർ, വിലാസം തുടങ്ങിയവ പോലുള്ള ഒരു കൂട്ടം ആട്രിബ്യൂട്ടുകളുള്ള ഒരു ഉപഭോക്താവിനെക്കുറിച്ച് ചിന്തിക്കുക. ഇപ്പോൾ ഈ ആട്രിബ്യൂട്ടുകൾ ഓരോന്നിനും ഒരു മൂല്യമുണ്ട്. ഉദാഹരണത്തിന്:
name = Jay
email = [email protected]
ഈ ഉദാഹരണത്തിൽ, ഞങ്ങളുടെ കീകൾ പേര്, ഇമെയിൽ, ഫോൺ എന്നിവയാണ്. ഓരോ കീയും ഒരു മൂല്യവുമായി ബന്ധപ്പെട്ടിരിക്കുന്നു, അതിനാൽ ഇവിടെയാണ് നമ്മൾ ഒരു നിഘണ്ടു ഉപയോഗിക്കുന്നത്. ഒരു നിഘണ്ടു ഉപയോഗിച്ച്, നമുക്ക് ഒരു കൂട്ടം കീ-വാല്യൂ ജോഡികൾ സംഭരിക്കാൻ കഴിയും. പൈത്തണിൽ ഒരു നിഘണ്ടു എങ്ങനെ നിർവചിക്കാമെന്ന് ഞാൻ കാണിച്ചുതരാം.
customer = {
"name": "Jay",
"email": "[email protected]",
"age": 30,
"is_verified": True
}
കീ സ്ട്രിംഗുകൾ, അക്കങ്ങൾ, ബൂളിയൻ അല്ലെങ്കിൽ മറ്റെന്തെങ്കിലും ആയി സജ്ജീകരിക്കാം. കീകൾ അദ്വിതീയമാണ്, ഒരു തവണ മാത്രമേ നിർവചിക്കാനാകൂ, അതായത് എനിക്ക് മറ്റൊരു നമ്പർ ഉപയോഗിച്ച് "പ്രായം" വീണ്ടും നിർവചിക്കാൻ കഴിയില്ല. അവരും കേസ് സെൻസിറ്റീവ് ആണ്.
ഇപ്പോൾ, ഞാൻ ടൈപ്പ് ചെയ്താൽ customer["name"],
അത് ഉപഭോക്താവിന്റെ പേര് വിളിക്കും. നമുക്ക് ഇത് ടെർമിനലിൽ പ്രിന്റ് ചെയ്യാം:
നിഘണ്ടുക്കൾക്കൊപ്പം നമുക്ക് രീതികളും ഉപയോഗിക്കാം. മുകളിൽ കാണിച്ചിരിക്കുന്ന അതേ ഫംഗ്ഷൻ "ഗെറ്റ്" രീതി ഉപയോഗിച്ച് ആവർത്തിക്കാനാകും.
മുകളിൽ പറഞ്ഞ രണ്ട് രീതികളും തമ്മിൽ ഒരു പ്രത്യേക വ്യത്യാസമുണ്ട്. അത് ഞാൻ തെളിയിക്കട്ടെ.
നിലവിലില്ലാത്ത ഒരു കീ ഞങ്ങൾ ലളിതമായി പ്രിന്റ് ചെയ്തപ്പോൾ, അത് ഒരു പിശകിൽ കലാശിച്ചതായി നിങ്ങൾക്ക് കാണാൻ കഴിയും. മറുവശത്ത്, നിലവിലില്ലാത്ത കീകൾ വിളിക്കുന്നതിനുള്ള രീതി ഉപയോഗിക്കുന്നത് മൂല്യത്തിന്റെ അഭാവത്തെ പ്രതിനിധീകരിക്കുന്ന ഒരു "ഒന്നുമില്ല" ഫലത്തിൽ കലാശിക്കുന്നു. "ഗെറ്റ്" രീതി ഉപയോഗിക്കുമ്പോൾ, നമുക്ക് ഒരു ഡിഫോൾട്ട് മൂല്യവും നൽകാം.
ഉദാഹരണത്തിന്, ഈ നിഘണ്ടുവിന് “ജന്മദിനം” കീ ഇല്ലെങ്കിൽ, നമുക്ക് ഇത് ഇതുപോലെ നൽകാം:
customer.get("birthdate", "Jan 01, 1994")
ഒരു ലിസ്റ്റിന് സമാനമായി നിഘണ്ടുവിലെ ഏത് കീയും നമുക്ക് അപ്ഡേറ്റ് ചെയ്യാനും കഴിയും. നമ്മുടെ നിഘണ്ടുവിലെ നെയിം കീ അപ്ഡേറ്റ് ചെയ്യാൻ ആഗ്രഹിക്കുന്നുവെന്ന് പറയാം. ഞങ്ങൾ അത് എങ്ങനെ ചെയ്യുമെന്ന് ഇതാ.
customer["name"] = "Shahbaz"
ഞങ്ങളുടെ നിഘണ്ടുവിലും ഒരു പുതിയ കീ ചേർക്കാൻ സമാനമായ വാക്യഘടന ഉപയോഗിക്കാം. സമാനമായ രീതിയിൽ "ജന്മദിനം" എന്ന കീ ചേർക്കാം.
customer["birthdate"] = "Jan 01, 1994"
അതിനാൽ, പൈത്തണിൽ നിഘണ്ടുക്കൾ ഉപയോഗിക്കുന്നതിനുള്ള അടിസ്ഥാനകാര്യങ്ങൾ ഇതാണ്. അവ വളരെ പ്രധാനമാണ് കൂടാതെ അവർക്ക് യഥാർത്ഥ ലോകത്ത് ധാരാളം ആപ്ലിക്കേഷനുകളുണ്ട്.
വ്യായാമം
അക്കങ്ങളെ ഇതുപോലുള്ള വാക്കുകളാക്കി മാറ്റുന്ന ഒരു പ്രോഗ്രാം നിങ്ങൾ എഴുതാൻ പോകുന്നു:
പരിഹാരം
നിങ്ങൾക്കുള്ള പരിഹാരം ഇതാ.
phone = input("Phone: ")
digits_mapping = {
"1": "One",
"2": "Two",
"3": "Three",
"4": "Four",
"5": "Five",
"6": "Six",
"7": "Seven",
"8": "Eight",
"9": "Nine",
"0": "Zero"
}
output = " "
for ch in phone:
output += digits_mapping.get(ch, "!") + " "
print(output)
അതുപോലെ, നിങ്ങൾക്ക് "ഇമോജി കൺവെർട്ടർ" പോലെയുള്ള മറ്റ് രസകരമായ പ്രോഗ്രാമുകൾ നിർമ്മിക്കാൻ കഴിയും പൈത്തണേഴ്സ് ആസ്വദിക്കൂ!
അവസാനിപ്പിക്കുക!
നിങ്ങൾ ഈ പ്രഭാഷണം ആസ്വദിച്ചുവെന്ന് ഞാൻ പ്രതീക്ഷിക്കുന്നു. അടുത്തതായി, പൈത്തൺ പ്രോഗ്രാമിംഗ്, ഫംഗ്ഷനുകൾ, പാരാമീറ്ററുകൾ എന്നിവയുടെ ഒരു സുപ്രധാന വശത്തിലേക്ക് ഞങ്ങൾ പ്രവേശിക്കാൻ പോകുന്നു.
നിങ്ങളുടെ അഭിപ്രായങ്ങൾ രേഖപ്പെടുത്തുക