പ്രോഗ്രാമിംഗിൽ, ലിസ്റ്റുകൾ ഒരുപക്ഷേ അറേകൾ പോലെ ഉപയോഗപ്രദമായ ഒരു ഡാറ്റ ഘടനയാണ്. എന്താണ് ലിസ്റ്റുകൾ, അവ എങ്ങനെ സൃഷ്ടിക്കാം? പൈത്തണിലെ ലിസ്റ്റുകൾ ഉപയോഗിച്ച് എങ്ങനെ പ്രവർത്തിക്കാം? ഞങ്ങളുടെ ലേഖനത്തിൽ നിന്ന് നിങ്ങൾ ഇതിനെക്കുറിച്ച് പഠിക്കും.

പൈത്തണിലെ ലിസ്റ്റുകൾ എന്തൊക്കെയാണ്?

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

പൈത്തണിലെ ഒരു ലിസ്‌റ്റ് എന്നത് പരിഷ്‌ക്കരിക്കാവുന്നതും ഒബ്‌ജക്‌റ്റുകൾ വ്യത്യാസപ്പെട്ടിരിക്കാവുന്നതുമായ മിശ്രിത തരത്തിലുള്ള ഒബ്‌ജക്‌റ്റുകളുടെ ക്രമപ്പെടുത്തിയ ശേഖരമാണ്.

എന്താണ് ഇതിനർത്ഥം? നിർവചനം വിശദമായി നോക്കാം.

ലിസ്റ്റിംഗിന്റെ വലുപ്പം മാറ്റാനും കുറയ്ക്കാനും അതിൽ പുതിയ വരികൾ ചേർക്കാനും കഴിയും. നിങ്ങൾക്ക് പട്ടികയുടെ മുഴുവൻ ഘടനയും മാറ്റാം. ഓരോ തവണയും ഒരു ലിസ്റ്റിലെ ഒരു രീതി ഉപയോഗിക്കുമ്പോൾ, യഥാർത്ഥ ലിസ്റ്റ് മാറ്റപ്പെടും, പകർപ്പല്ല.

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

ഒരു ലിസ്റ്റ് സൃഷ്ടിക്കുന്നതിനുള്ള വഴികൾ

ക്ലാസിക് ഉദാഹരണത്തിലേക്ക് നീങ്ങുമ്പോൾ, ഭാവിയിൽ ഞങ്ങൾ ഉപയോഗിക്കുകയും പരിഷ്കരിക്കുകയും ചെയ്യുന്ന ഒരു ലിസ്റ്റ് സൃഷ്ടിക്കാം. ലിസ്റ്റിംഗുകൾ സൃഷ്ടിക്കുന്നതിന് നിരവധി മാർഗങ്ങളുണ്ട്.

അതിലൊന്നാണ് അപേക്ഷ അന്തർനിർമ്മിത പ്രവർത്തന പട്ടിക( ). ഇത് ചെയ്യുന്നതിന്, നിങ്ങൾക്ക് ആവർത്തിക്കാൻ കഴിയുന്ന ഏതെങ്കിലും ഒബ്ജക്റ്റ് പ്രോസസ്സ് ചെയ്യേണ്ടതുണ്ട് (ഒരു സ്ട്രിംഗ്, ഒരു ട്യൂപ്പിൾ അല്ലെങ്കിൽ നിലവിലുള്ള ഒരു ലിസ്റ്റ്). ഈ സാഹചര്യത്തിൽ, ഒരു സ്ട്രിംഗ്.

അവസാനം സംഭവിക്കുന്നത് ഇതാ:

>>> ലിസ്റ്റ് ('ലിസ്റ്റ്') ['c', 'n', 'i', 'c', 'o', 'to']

രണ്ടാമത്തെ ഉദാഹരണം കാണിക്കുന്നത് ലിസ്റ്റുകളിൽ വളരെ വ്യത്യസ്തമായ ഒബ്‌ജക്റ്റുകളുടെ പരിധിയില്ലാത്ത എണ്ണം അടങ്ങിയിരിക്കാം എന്നാണ്. കൂടാതെ, ലിസ്റ്റിംഗ് ശൂന്യമായി തുടരാം.

>>> s = [] # ശൂന്യമായ ലിസ്റ്റ് >>> l = ['s', 'p', ['isok'], 2] >>> s [] >>> l ['s', 'p' , ['isok'], 2]

ലിസ്റ്റിംഗുകൾ രൂപീകരിക്കുന്നതിനുള്ള അടുത്ത, മൂന്നാമത്തേത്, വിളിക്കപ്പെടുന്നവയാണ് ലിസ്റ്റിംഗ് ജനറേറ്റർ.

ലിസ്റ്റിംഗുകൾ സൃഷ്ടിക്കുന്നതിനുള്ള ഒരു വാക്യഘടനയാണ് ലിസ്റ്റിംഗ് ജനറേറ്റർ. ഇത് ഫോർ ലൂപ്പിന് സമാനമാണ്.

>>> c = ['ലിസ്റ്റിലെ' c എന്നതിനുള്ള c * 3] >>> c ['lll', 'iii', 'sss', 'ttt']

കൂടുതൽ വലിയ ഘടനകൾ സൃഷ്ടിക്കുന്നതിനും ഇത് ഉപയോഗിക്കാം:

>>> c = [c * 3 for 'list' if c != 'i'] >>> c ['lll', 'sss', 'ttt'] >>> c = [c + d for 'ലിസ്‌റ്റിൽ' c != 'i' എന്നതിന് 'സ്പാമിൽ' d != 'a'] >>> c ['ls', 'lp', 'lm', 'ss', 'sp' , 'sm', 'ts', 'tp', 'tm']

എന്നിരുന്നാലും, ഒന്നിലധികം ലിസ്റ്റിംഗുകൾ കംപൈൽ ചെയ്യുമ്പോൾ ഈ ജനറേഷൻ രീതി എല്ലായ്പ്പോഴും കാര്യക്ഷമമല്ല. അതിനാൽ, ലിസ്റ്റിംഗുകൾ സൃഷ്ടിക്കുന്നതിന് ഫോർ ലൂപ്പ് ഉപയോഗിക്കുന്നതാണ് ഉചിതം.

നിങ്ങൾക്ക് ലിസ്റ്റിൽ നിന്ന് ഏതെങ്കിലും ഘടകം പരാമർശിക്കണമെങ്കിൽ, സൂചികകൾ ഉപയോഗിക്കും. ഓരോ മൂലകത്തിനും അതിന്റേതായ സൂചികയുണ്ട്.

ലിസ്റ്റിലെ മൂലകത്തിന്റെ എണ്ണമാണ് സൂചിക.

നിങ്ങൾക്ക് ആവർത്തിക്കുന്ന, സമാന ഘടകങ്ങൾ ഉപയോഗിച്ച് ലിസ്റ്റിംഗ് പൂരിപ്പിക്കണമെങ്കിൽ, * ചിഹ്നം ഉപയോഗിക്കുന്നു. ഉദാഹരണത്തിന്, നിങ്ങൾ ലിസ്റ്റിംഗിലേക്ക് സമാനമായ മൂന്ന് സംഖ്യകൾ ചേർക്കേണ്ടതുണ്ട്: [100] * 3.

ലിസ്റ്റിംഗ് പ്രവർത്തനങ്ങൾ

ഫംഗ്ഷനുകളും - ഇത് ഒരുപക്ഷേ മറ്റ് പ്രോഗ്രാമിംഗ് ഭാഷകളെ അപേക്ഷിച്ച് പൈത്തണിന്റെ പ്രധാന നേട്ടമാണ്. അടിസ്ഥാന ബിൽറ്റ്-ഇൻ ഫംഗ്ഷനുകൾ ലിസ്റ്റുകളിലേക്ക് പ്രയോഗിക്കാൻ കഴിയും.

അവയിൽ ഏറ്റവും ജനപ്രിയമായത് പരിഗണിക്കുക:

• പട്ടിക(പരിധി()) - ഒരു സീക്വൻഷ്യൽ ലിസ്റ്റ് സൃഷ്ടിക്കുക എന്നതാണ് ചുമതല എങ്കിൽ, ശ്രേണി ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നു. ഈ പ്രവർത്തനത്തിന് ഇനിപ്പറയുന്ന ഫോമുകൾ ഉണ്ട്:

1. ശ്രേണി(അവസാനം). പൂജ്യത്തിൽ നിന്ന് ഒരു പരിമിത സംഖ്യയിലേക്ക് ഒരു ലിസ്‌റ്റിംഗ് സൃഷ്‌ടിക്കേണ്ടിവരുമ്പോൾ ഇത് ഉപയോഗിക്കുന്നു.
2. ശ്രേണി (ആരംഭം, അവസാനം). ആരംഭ, അവസാന സംഖ്യകൾ വ്യക്തമാക്കുന്നു.
3. ശ്രേണി (ആരംഭം, അവസാനം, ഘട്ടം). സ്റ്റെപ്പ് പാരാമീറ്റർ തിരഞ്ഞെടുക്കൽ സ്വഭാവം വ്യക്തമാക്കുന്നു. ഉദാഹരണത്തിന്, 1 മുതൽ 21 വരെയുള്ള ഒരു ശ്രേണിയിൽ നിന്ന് ഓരോ അഞ്ചാമത്തെ സംഖ്യയും തിരഞ്ഞെടുക്കണമെങ്കിൽ, ഫലമായുണ്ടാകുന്ന ലിസ്റ്റിംഗ് ഇതുപോലെ കാണപ്പെടും: [10,15, 20].

ശ്രേണി പ്രവർത്തനത്തിന് കോഡിന്റെ അളവ് ഗണ്യമായി കുറയ്ക്കാൻ കഴിയും.

• ഫ്ളാക്സ് (പട്ടിക) - ലിസ്റ്റിൽ എത്ര ഘടകങ്ങൾ ഉണ്ടെന്ന് കണ്ടെത്താൻ നിങ്ങളെ അനുവദിക്കുന്നു.
• അടുക്കിയത് (ലിസ്റ്റ്, [കീ]) - ലിസ്റ്റിലെ ഒബ്ജക്റ്റുകളെ ആരോഹണ ക്രമത്തിൽ അടുക്കുന്നു.
• പരമാവധി (പട്ടിക) - ഏറ്റവും വലിയ ഘടകം നൽകുന്നു.
• മിനിറ്റ് (പട്ടിക) - വിപരീത പ്രവർത്തനം - ഏറ്റവും കുറഞ്ഞ മൂല്യമുള്ള ഘടകം തിരികെ നൽകാൻ നിങ്ങളെ അനുവദിക്കുന്നു.

നിങ്ങൾക്ക് മറ്റ് ബിൽറ്റ്-ഇൻ ഫംഗ്ഷനുകളും ഉപയോഗിക്കാം:

• പട്ടിക (ട്യൂപ്പിൾ) - ഒരു ട്യൂപ്പിൾ ഒബ്ജക്റ്റിനെ ഒരു ലിസ്റ്റിലേക്ക് പരിവർത്തനം ചെയ്യുന്നു.
• തുക(പട്ടിക) - എല്ലാ മൂല്യങ്ങളും സംഖ്യകളാണെങ്കിൽ പട്ടികയിലെ എല്ലാ ഘടകങ്ങളും സംഗ്രഹിക്കുന്നു, പൂർണ്ണസംഖ്യകൾക്കും ദശാംശങ്ങൾക്കും ബാധകമാണ്. എന്നിരുന്നാലും, അവൾ എല്ലായ്പ്പോഴും അത് ശരിയായി മനസ്സിലാക്കുന്നില്ല. ലിസ്റ്റിൽ ഒരു നോൺ-ന്യൂമറിക് എലമെന്റ് ഉണ്ടെങ്കിൽ, ഫംഗ്‌ഷൻ ഒരു പിശക് വരുത്തും: “ടൈപ്പ് പിശക്: +: 'int', 'str' എന്നിവയ്‌ക്കായുള്ള പിന്തുണയ്‌ക്കാത്ത ഓപ്പറാൻറ് തരം(കൾ)”.

ലിസ്റ്റിംഗ് രീതികൾ

സ്റ്റോറിൽ നിന്ന് വാങ്ങേണ്ട ഇനങ്ങളുടെ ലിസ്റ്റിലേക്ക് തിരികെ പോയി അതിനെ ഷോപ്പ്ലിസ്റ്റ് എന്ന് വിളിക്കാം:

ഷോപ്പ് ലിസ്റ്റ് = []

അടുത്തതായി, ലിസ്റ്റിംഗ് രീതികൾ പരിഗണിക്കുക:

• അനുബന്ധം (ഇനം) - അതിന്റെ സഹായത്തോടെ, നിങ്ങൾക്ക് പട്ടികയിലേക്ക് ഒരു ഘടകം ചേർക്കാൻ കഴിയും. ഈ സാഹചര്യത്തിൽ, പുതിയ ഘടകം അവസാനം ആയിരിക്കും.

ശരിയായ ഉൽപ്പന്നങ്ങൾ ഉപയോഗിച്ച് ഞങ്ങളുടെ പുതിയ ലിസ്റ്റിംഗ് പൂരിപ്പിക്കാം:

shoplist.append(bread)

shoplist.append(പാൽ)

• പട്ടിക.നീട്ടുക(A) - "ലിസ്റ്റിലേക്ക് ലിസ്റ്റ്" ചേർക്കുന്നു. ഒരേ സമയം ഒന്നിലധികം ഇനങ്ങൾ ചേർക്കാൻ കഴിയുന്നതിനാൽ ഈ സവിശേഷത സമയം ലാഭിക്കുന്നു. നമുക്ക് ഇതിനകം പഴങ്ങളുടെ ഒരു ലിസ്റ്റ് ഉണ്ടെന്ന് പറയാം, അവയെ പ്രധാന പട്ടികയിലേക്ക് ചേർക്കേണ്ടതുണ്ട്.

shoplist.extend(പഴങ്ങൾ)

• തിരുകുക (സൂചിക, ഇനം) - നിർദ്ദിഷ്ട സൂചികയ്‌ക്ക് മുമ്പുള്ള നിർദ്ദിഷ്ട മൂല്യം നിർദ്ദിഷ്ട സൂചികയുള്ള മൂലകത്തിൽ ചേർക്കുക.
• എണ്ണം(ഇനം) - മൂലകത്തിന്റെ ആവർത്തനങ്ങളുടെ എണ്ണം കാണിക്കുന്നു.
• പട്ടിക.നീക്കം ചെയ്യുക(ഇനം) വിപരീത പ്രവർത്തനമാണ് പട്ടിക.കൂട്ടിച്ചേർക്കുക (x). ഏത് മൂലകവും നീക്കം ചെയ്യാൻ ഇത് ഉപയോഗിക്കാം. തിരഞ്ഞെടുത്ത ഇനം ലിസ്റ്റിൽ ഇല്ലെങ്കിൽ, ഒരു പിശക് റിപ്പോർട്ട് ചെയ്യപ്പെടും.
• പോപ്പ് ([സൂചിക]) - തിരഞ്ഞെടുത്ത ഘടകം നീക്കം ചെയ്യുകയും അതേ രീതിയിൽ തിരികെ നൽകുകയും ചെയ്യുന്നു. ഘടകം വ്യക്തമാക്കിയിട്ടില്ലെങ്കിൽ, അവസാന ഘടകം പട്ടികയിൽ നിന്ന് നീക്കം ചെയ്യും.
• അടുക്കുക ([കീ]) - ലിസ്റ്റിംഗിലെ ഘടകങ്ങൾ ആരോഹണ ക്രമത്തിൽ ഇടുന്നു, എന്നാൽ നിങ്ങൾക്ക് ഒരു ഫംഗ്ഷൻ വ്യക്തമാക്കാനും കഴിയും.
• സൂചിക(ഇനം) - ആദ്യം തിരഞ്ഞെടുത്ത മൂലകത്തിന്റെ സൂചിക കാണിക്കുന്നു.
• നിങ്ങൾക്ക് ലിസ്റ്റ് വികസിപ്പിക്കാൻ കഴിയും, അതായത്, അതിന്റെ എല്ലാ ഘടകങ്ങളും മിറർ ചെയ്യുക, രീതി ഉപയോഗിച്ച് വിപരീത (ലിസ്റ്റ്). അവസാനത്തെ മൂലകം ആദ്യത്തേതാകുന്നു, അവസാനത്തെ മൂലകം രണ്ടാമത്തേതാകുന്നു, എന്നിങ്ങനെ.
• കമാൻഡ് ഉപയോഗിച്ച് പട്ടികയുടെ ഒരു പകർപ്പ് സൃഷ്ടിക്കപ്പെടുന്നു പകർത്തുക (പട്ടിക).
• ആഴത്തിലുള്ള പകർപ്പ് (പട്ടിക) - ആഴത്തിലുള്ള പകർത്തൽ.
• രീതി ഉപയോഗിച്ച് എല്ലാ ലിസ്റ്റിംഗ് ഘടകങ്ങളും നീക്കം ചെയ്യുക വ്യക്തമായ പട്ടിക).

ലിസ്റ്റിംഗ് രീതികൾ സ്ട്രിംഗ് രീതികളിൽ നിന്ന് വ്യത്യസ്തമാണ് എന്നത് ശ്രദ്ധിക്കേണ്ടതാണ്, അവ ഉടനടി ലിസ്റ്റ് മാറ്റുന്നു, അതായത്, എക്സിക്യൂഷന്റെ ഫലം തിരികെ നൽകേണ്ടതില്ല.

>>> l = [1, 2, 3, 5, 7] >>> l.sort() >>> l [1, 2, 3, 5, 7] >>> l = l.sort() > >> പ്രിന്റ് (എൽ) ഒന്നുമില്ല

ലിസ്റ്റുകൾക്കൊപ്പം പ്രവർത്തിക്കുന്നതിനുള്ള ഒരു ഉദാഹരണം ഇനിപ്പറയുന്നതാണ്:

>>> a = [66.25, 333, 333, 1, 1234.5] >>> പ്രിന്റ്(a.count(333), a.count(66.25), a.count('x')) 2 1 0 >>> a.insert(2, -1) >>> a.append(333) >>> a [66.25, 333, -1, 333, 1, 1234.5, 333] >>> a.index(333) 1 >> > a.remove(333) >>> a [66.25, -1, 333, 1, 1234.5, 333] >>> a.reverse() >>> a [333, 1234.5, 1, 333, -1, 66.25 ] >>> a.sort() >>> a [-1, 1, 66.25, 333, 333, 1234.5]