പൈത്തൺ ലിസ്റ്റ് ഡാറ്റാ ഘടന പഠിക്കുക - ഭാഗം 1
ഡാറ്റാ തരങ്ങൾ, അവ തമ്മിലുള്ള ബന്ധം, ഡാറ്റയിൽ പ്രയോഗിക്കാൻ കഴിയുന്ന പ്രവർത്തനങ്ങൾ അല്ലെങ്കിൽ പ്രവർത്തനങ്ങൾ എന്നിവയുടെ ഒരു ശേഖരമാണ് ഡാറ്റാ ഘടന. ഡാറ്റ തരം സ്ട്രിംഗ്, പൂർണ്ണസംഖ്യ, ഫ്ലോട്ടിംഗ് മൂല്യം മുതലായവ ആകാം.
- എലമെന്റുകൾ ചേർക്കൽ, അപ്ഡേറ്റ് ചെയ്യുക അല്ലെങ്കിൽ ഇല്ലാതാക്കൽ പോലെയുള്ള ഒബ്ജക്റ്റുകൾ സൃഷ്ടിച്ചുകഴിഞ്ഞാൽ അതിന്റെ അവസ്ഥ മാറ്റാൻ കഴിയും.
- ലിസ്റ്റുകൾ, നിഘണ്ടു, സെറ്റ്, ബൈറ്റേറേ എന്നിവ പൈത്തണിലെ മാറ്റാവുന്ന ഒബ്uജക്റ്റ് തരങ്ങളാണ്.
- ഒബ്ജക്റ്റ് അവസ്ഥ പരിഷ്കരിക്കാൻ കഴിയില്ല. ഒബ്ജക്റ്റ് സൃഷ്ടിച്ചുകഴിഞ്ഞാൽ, ഘടകങ്ങൾ ചേർക്കാനോ നീക്കം ചെയ്യാനോ അപ്ഡേറ്റ് ചെയ്യാനോ ഞങ്ങൾക്ക് കഴിയില്ല.
- സ്ട്രിംഗ്, പൂർണ്ണസംഖ്യ, ട്യൂപ്പിൾസ്, ഫ്രോസൺസെറ്റ് എന്നിവയാണ് പൈത്തണിലെ മാറ്റമില്ലാത്ത ഒബ്uജക്റ്റ് തരങ്ങളിൽ ചിലത്.
- ഏകരൂപത്തിലുള്ള ഡാറ്റാ ഘടന - ഡാറ്റ ഘടകങ്ങൾ ഒരേ ഡാറ്റാ തരത്തിലായിരിക്കും (ഉദാ: അറേ).
- വൈവിദ്ധ്യമാർന്ന ഡാറ്റാ ഘടന - ഡാറ്റ ഘടകങ്ങൾ ഒരേ തരത്തിലുള്ള ഡാറ്റ ആയിരിക്കണമെന്നില്ല (ഉദാ: ലിസ്റ്റ്, ട്യൂപ്പിൾസ്, സെറ്റുകൾ മുതലായവ...).
ബിൽറ്റ്-ഇൻ ഡാറ്റാ ഘടനയുടെ പ്രവർത്തനക്ഷമത മനസ്സിലാക്കുന്നതിന് മുമ്പ്, ഡാറ്റാ ഘടനാ ഒബ്uജക്uറ്റുകൾക്കൊപ്പം ഉപയോഗിക്കുന്ന കുറച്ച് ബിൽറ്റ്-ഇൻ ഫംഗ്uഷനുകൾ നമുക്ക് നോക്കാം.
- dir(obj) - ആട്രിബ്യൂട്ടും രീതികളും നൽകുന്ന ഒരു ബിൽറ്റ്-ഇൻ ഫംഗ്uഷൻ.
- len(obj) - ഒരു വസ്തുവിന്റെ ദൈർഘ്യം (ഇനങ്ങളുടെ എണ്ണം) തിരികെ നൽകുക. ആർഗ്യുമെന്റ് ഒരു സീക്വൻസ് (സ്ട്രിംഗ്, ബൈറ്റുകൾ, ട്യൂപ്പിൾ, ലിസ്റ്റ് അല്ലെങ്കിൽ റേഞ്ച് പോലുള്ളവ) അല്ലെങ്കിൽ ഒരു ശേഖരം (നിഘണ്ടു, സെറ്റ് അല്ലെങ്കിൽ ഫ്രോസൺ സെറ്റ് പോലുള്ളവ) ആകാം.
- del - ഈ ബിൽറ്റ്-ഇൻ കീവേഡ് ഒരു നെയിംസ്uപെയ്uസിൽ നിന്ന് ഒരു ഒബ്uജക്റ്റ് ഇല്ലാതാക്കുന്നതിനോ ഒരു ലിസ്റ്റ്, നിഘണ്ടു മുതലായ ഒബ്uജക്റ്റിൽ നിന്ന് ഇനങ്ങൾ നീക്കംചെയ്യുന്നതിനോ ഉപയോഗിക്കുന്നു.
- type(obj) – ടൈപ്പ്() ഫംഗ്uഷൻ ഒന്നുകിൽ ഒബ്uജക്റ്റിന്റെ തരം നൽകുന്നു അല്ലെങ്കിൽ പാസാക്കിയ ആർഗ്യുമെന്റുകളെ അടിസ്ഥാനമാക്കി ഒരു പുതിയ തരം ഒബ്uജക്റ്റ് നൽകുന്നു.
- id() – ഈ ഫംഗ്uഷൻ ഒരു ഒബ്uജക്റ്റിന്റെ \ഐഡന്റിറ്റി നൽകുന്നു. ഈ ഒബ്uജക്റ്റിന് അതിന്റെ ജീവിതകാലത്ത് അദ്വിതീയവും സ്ഥിരവുമായിരിക്കുമെന്ന് ഉറപ്പുനൽകുന്ന ഒരു പൂർണ്ണസംഖ്യയാണിത്.
ഇപ്പോൾ നിങ്ങൾ കുറച്ച് പ്രധാനപ്പെട്ട വിശദാംശങ്ങൾ കണ്ടതിനാൽ, നമുക്ക് പൈത്തൺ ഡാറ്റാ ഘടനകളുമായി മുന്നോട്ട് പോകാം.
പൈത്തൺ ബിൽറ്റ്-ഇൻ ഡാറ്റാ ഘടനകളുമായാണ് വരുന്നത്, അതുപോലെ തന്നെ ഉപയോക്താക്കൾക്ക് അവരുടെ സ്വന്തം ഡാറ്റ ഘടനകൾ നിർവചിക്കാനാകും. ബിൽറ്റ്-ഇൻ ഡാറ്റാ ഘടനയിൽ ലിസ്റ്റ്, ഡിക്ഷണറി, ട്യൂപ്പിൾ, സെറ്റ് എന്നിവ ഉൾപ്പെടുന്നു. ഉപയോക്തൃ-നിർവചിച്ച ഡാറ്റ ഘടനകൾക്കുള്ള ചില ഉദാഹരണങ്ങൾ സ്റ്റാക്ക്, ക്യൂസ്, ട്രീ, ഹാഷ്മാപ്പ് മുതലായവയാണ്...
മറ്റ് പ്രോഗ്രാമിംഗ് ഭാഷകളിൽ നിന്ന് വരുന്ന ആളുകൾക്ക് ഒരു അറേ തരം വളരെ പരിചിതമായിരിക്കും. എന്നാൽ പൈത്തണിൽ അവ അത്ര സാധാരണമല്ല.
ഇവിടെ ലിസ്uറ്റ് ഒരു അറേയ്uക്ക് സമാനമാണ്, എന്നാൽ ഏത് ഡാറ്റാ തരത്തിന്റെയും (വിജാതീയമായ) മൂല്യങ്ങൾ സംഭരിക്കാൻ ലിസ്uറ്റ് ഞങ്ങളെ അനുവദിക്കുന്നു, അതേസമയം പ്രത്യേക തരം ഡാറ്റ മാത്രം അറേയിൽ സൂക്ഷിക്കും (int, float etc...). അറേ ഉപയോഗിക്കുന്നതിന് നിങ്ങൾ അറേ മൊഡ്യൂളിൽ നിന്ന് അറേ വ്യക്തമായി ഇറക്കുമതി ചെയ്യണം.
ഈ പൈത്തൺ ലേഖനങ്ങളുടെ പരമ്പരയിൽ, ഒരു ഡാറ്റാ ഘടനയും പൈത്തൺ ബിൽറ്റ്-ഇൻ ഡാറ്റാ ഘടനയും എന്താണെന്ന് ഞങ്ങൾ നോക്കും.
വിവിധ ഡാറ്റാ തരങ്ങളുടെ ശേഖരണമായ ഒരു ഡാറ്റാ ഘടനയാണ് ലിസ്റ്റ്. \വ്യത്യസ്uത ഡാറ്റാ തരങ്ങളുടെ ശേഖരണം എന്താണ് അർത്ഥമാക്കുന്നത്? സ്ട്രിംഗുകൾ, പൂർണ്ണസംഖ്യകൾ, ഫ്ലോട്ടിംഗ് പോയിന്റ് മൂല്യങ്ങൾ, നെസ്റ്റഡ് ലിസ്റ്റ് തുടങ്ങിയവ സംഭരിക്കാൻ ലിസ്റ്റിന് കഴിയും.
ലിസ്റ്റ് ഒബ്uജക്റ്റുകൾ \മ്യൂട്ടബിൾ ആണ്, അതിനർത്ഥം ലിസ്റ്റിനുള്ളിൽ സൃഷ്uടിച്ച ഇനങ്ങൾ ആക്uസസ് ചെയ്യാനോ പരിഷ്uക്കരിക്കാനോ ഇല്ലാതാക്കാനോ കഴിയും എന്നാണ്. ലിസ്റ്റ് പിന്തുണ സൂചികയാക്കൽ. ലിസ്റ്റുകളിലെ ഓരോ ഇനവും ഒരു വിലാസത്തിലേക്ക് അസൈൻ ചെയ്uതിരിക്കുന്നു, പ്രത്യേക ഇന മൂല്യം ആക്uസസ് ചെയ്യാനോ പരിഷ്uക്കരിക്കാനോ ആ വിലാസം ഉപയോഗിക്കാം. .
- ഒരു ലിസ്റ്റ് സൃഷ്uടിക്കുക
- ലിസ്uറ്റ് തിരുകുക/ആക്സസ് ചെയ്യുക/മാറ്റുക
- ലിസ്റ്റ് ഇല്ലാതാക്കുക
സ്ക്വയർ ബ്രാക്കറ്റുകൾ ഉപയോഗിച്ച് ലിസ്റ്റ് സൃഷ്ടിക്കാൻ കഴിയും.
>>> name_empty = [] # Empty list >>> name = ['Karthi', 'Leo', 'Matt', 'Kane', 'Scott', 'Petter', 'Will'] # list with string data type >>> name_int = [1,2,3] # list with Integer data type >>> name_mixed = [name_int,name,1,2,3.14] # list with nested list items. >>> name_mixed [[1, 2, 3], ['Karthi', 'Leo', 'Matt', 'Kane', 'Scott', 'Petter', 'Will'], 1, 2, 3.14] >>> name_int [1, 2, 3]
ഒബ്uജക്റ്റ് തരം പരിശോധിക്കാൻ നമുക്ക് ഇൻബിൽറ്റ് type() ഫംഗ്uഷൻ ഉപയോഗിക്കാം.
>>> type(name)
dir() ഫംഗ്uഷൻ ഉപയോഗിച്ച് ലിസ്റ്റ് സംഭവത്തിന്റെ രീതികളും ആട്രിബ്യൂട്ടുകളും നമുക്ക് ആക്uസസ് ചെയ്യാൻ കഴിയും.
>>> dir(name) ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
len() രീതി ഉപയോഗിച്ച് ലിസ്റ്റിലെ മൊത്തം ഇനങ്ങളുടെ എണ്ണം നമുക്ക് കണ്ടെത്താനാകും.
>>> len(name)
list.copy() രീതി ഉപയോഗിച്ച് നിലവിലുള്ള ഒരു ലിസ്റ്റിൽ നിന്ന് നമുക്ക് ഒരു പുതിയ ലിസ്റ്റ് സൃഷ്ടിക്കാൻ കഴിയും.
>>> name_new = name.copy() >>> name_new ['Karthi', 'Leo', 'Matt', 'Kane', 'Scott', 'Petter', 'Will']
list.insert(i, x) രീതി ഉപയോഗിച്ച് നമുക്ക് ഏത് സ്ഥാനത്തും ഒരു ലിസ്റ്റിലേക്ക് ഒരു ഇനം ചേർക്കാം.
>>> name = ['Leo','Matt','Kane','Scott','Petter','Will'] >>> name ['Leo', 'Matt', 'Kane', 'Scott', 'Petter', 'Will'] >>> name.insert(0,'Tom') # Insert method takes 2 arguments (Index position, Item) >>> name ['Tom', 'Leo', 'Matt', 'Kane', 'Scott', 'Petter', 'Will'] # Tom is inserted at the 0th position.
ലിസ്റ്റിൽ ഒരൊറ്റ ഇനം കൂട്ടിച്ചേർക്കാൻ നമുക്ക് list.append(x) രീതി ഉപയോഗിക്കാം. ഇത് ലിസ്റ്റിന്റെ അവസാനം വരെ ഇനം തിരുകും.
>>> name = []
>>> len(name)
0
>>> name.append('Leo')
>>> name.append('Matt')
>>> name.append('Kane')
>>> print(name)
['Leo', 'Matt', 'Kane']
ലിസ്റ്റിലേക്ക് ഒന്നിലധികം ഇനങ്ങൾ ചേർക്കുന്നതിന് ഞങ്ങൾക്ക് list.extend() രീതി ഉപയോഗിക്കാം.
>>> new_name = ['Gowtham','Martin','Luis'] >>> name.extend(new_name) >>> name ['Will', 'Petter', 'Scott', 'Kane', 'Matt', 'Leo', 'Karthi', 'Will', 'Gowtham', 'Martin', 'Luis']
രണ്ട് ലിസ്റ്റ് സംയോജിപ്പിക്കാൻ നമുക്ക് + ഓപ്പറേറ്ററും ഉപയോഗിക്കാം. രണ്ട് ലിസ്റ്റും വ്യത്യസ്ത ഡാറ്റ തരങ്ങളാകാം.
>>> a = [1,2,3] >>> b = [2,3,3] >>> c = a + b >>> c [1, 2, 3, 2, 3, 3] >>> d = ['karthi','kenny'] >>> e = a + d >>> e [1, 2, 3, 'karthi', 'kenny']
ഇതിനകം പ്രസ്താവിച്ച പട്ടികയിൽ ഒബ്ജക്റ്റുകൾ മാറ്റാവുന്നവയാണ്. ഒരു ലിസ്റ്റ് ഇനം സൂചികയുടെ സ്ഥാനം റഫറൻസ് ചെയ്ത് അതിന് മൂല്യം നൽകിക്കൊണ്ട് പരിഷ്കരിക്കാനാകും.
>>> name # Before modified ['Tom', 'Leo', 'Matt', 'Kane', 'Scott', 'Petter', 'Will'] >>> name[0] = 'Karthi' >>> name # After Modified ['Karthi', 'Leo', 'Matt', 'Kane', 'Scott', 'Petter', 'Will']
ലിസ്റ്റ് പോസിറ്റീവ്, നെഗറ്റീവ് സൂചികയെ പിന്തുണയ്ക്കുന്നു.
ഇൻഡക്uസിംഗ് 0-ൽ നിന്നും നെഗറ്റീവ് ഇൻഡക്uസിംഗ് -1-ൽ നിന്നും ആരംഭിക്കുന്നു.
ലിസ്റ്റ് ഇനത്തിന്റെ സൂചിക സ്ഥാനം ഉപയോഗിച്ച് നമുക്ക് ആക്സസ് ചെയ്യാൻ കഴിയും.
>>> name[0] # Accessing the List item at index 0 'Leo' >>> name[1] 'Matt' >>> name[4] 'Petter' >>> name[5] 'Will' >>> name[-1] # Accessing the list item with negative indexing 'Will' >>> name[-6] 'Leo'
ലിസ്റ്റിലെ ഇനങ്ങൾ ആക്uസസ് ചെയ്യാൻ നമുക്ക് സ്ലൈസിംഗ് ഉപയോഗിക്കാം. സ്ലൈസിംഗ്, ആരംഭം, അവസാനം, ഘട്ടം പാരാമീറ്ററുകൾ നിർവചിച്ചുകൊണ്ട് ഒരു കൂട്ടം ഇനങ്ങൾ ആക്uസസ് ചെയ്യാൻ ഞങ്ങളെ അനുവദിക്കുന്നു.
# SYNTAX: list[starting position, ending position, Step] >>> name[0:3] ['Tom', 'Leo', 'Matt'] >>> name[:] ['Tom', 'Leo', 'Matt', 'Kane', 'Scott', 'Petter', 'Will'] >>> name[:4] ['Tom', 'Leo', 'Matt', 'Kane'] >>> name[:-2] ['Tom', 'Leo', 'Matt', 'Kane', 'Scott'] >>> name[:-1] ['Tom', 'Leo', 'Matt', 'Kane', 'Scott', 'Petter'] >>> name[:-1:2] ['Tom', 'Matt', 'Scott']
list.count(x) രീതി ഉപയോഗിച്ച് തന്നിരിക്കുന്ന മൂല്യത്തിനായുള്ള സംഭവങ്ങളുടെ എണ്ണം നമുക്ക് കണ്ടെത്താം.
>>> name_int = [1,1,2,3,1] >>> name_int.count(1) 3
list.index(x[, start[, end]]) രീതി ഉപയോഗിച്ച് തന്നിരിക്കുന്ന ഇനത്തിന്റെ സൂചിക സ്ഥാനം നമുക്ക് കണ്ടെത്താനാകും.
>>> name # Inserted ‘Will’ at the end of the list. Now we have 2 name ‘Will’.
['Will', 'Petter', 'Scott', 'Kane', 'Matt', 'Leo', 'Karthi', 'Will']
>>> name.index('Will) # Returns the index position of first occurence of x.
0
>>> name.index('Will',2) # Starting index positon’2’ is given.
7
>>> name.index('Will',2,4) # Starting and Ending Index position is given. Since there is no occurence of ‘Will’ within the given search position it will throw Value Error.
Traceback (most recent call last):
File "<stdin>", line 1, in
ValueError: 'Will' is not in list
ലിസ്റ്റിലെ ഇനങ്ങൾ റിവേഴ്സ് ചെയ്യാൻ നമുക്ക് list.reverse() രീതി ഉപയോഗിക്കാം.
>>> name ['Karthi', 'Leo', 'Matt', 'Kane', 'Scott', 'Petter', 'Will'] >>> name.reverse() >>> name ['Will', 'Petter', 'Scott', 'Kane', 'Matt', 'Leo', 'Karthi']
x സ്ഥാനത്തുള്ള ഒരു ലിസ്റ്റിൽ നിന്ന് ഒരു ഇനം നീക്കംചെയ്യാൻ ഞങ്ങൾക്ക് list.pop(x) രീതി ഉപയോഗിക്കാം. ഈ ഫംഗ്uഷൻ ലിസ്റ്റിൽ നിന്ന് ഇനം നീക്കം ചെയ്യുകയും നീക്കം ചെയ്uത ഇനം പ്രദർശിപ്പിക്കുകയും ചെയ്യും. x വ്യക്തമാക്കിയിട്ടില്ലെങ്കിൽ, pop() രീതി ലിസ്റ്റിൽ നിന്നുള്ള അവസാന ഇനം തിരികെ നൽകും.
>>> name ['Will', 'Petter', 'Scott', 'Kane', 'Matt', 'Leo', 'Karthi', 'Will', 'Gowtham', 'Martin', 'Luis'] >>> name.pop(0) 'Will' >>> name ['Petter', 'Scott', 'Kane', 'Matt', 'Leo', 'Karthi', 'Will', 'Gowtham', 'Martin', 'Luis'] >>> name.pop() 'Luis'
ലിസ്റ്റിൽ നിന്ന് ഇനം നീക്കംചെയ്യാൻ ഞങ്ങൾക്ക് list.remove (x) രീതിയും ഉപയോഗിക്കാം. ഇവിടെ x ഇനത്തിന്റെ മൂല്യം എടുക്കുകയും x ലിസ്റ്റിൽ ഇല്ലെങ്കിൽ ഒരു ValueError എറിയുകയും ചെയ്യുന്നു.
>>> name = ['Leo','Matt','Kane','Scott','Petter','Will']
>>> name.remove('Leo')
>>> name
['Matt', 'Kane', 'Scott', 'Petter', 'Will']
>>> name.remove('Leo')
Traceback (most recent call last):
File "", line 1, in
ValueError: list.remove(x): x not in list
സ്uക്വയർ ബ്രാക്കറ്റുകളിലേക്ക് ലിസ്uറ്റ് നാമം നൽകി അല്ലെങ്കിൽ list.clear() രീതി ഉപയോഗിച്ച് നമുക്ക് ഒരു ലിസ്റ്റ് ശൂന്യമാക്കാം.
>>> name1 = name.copy() >>> name1 ['Petter', 'Scott', 'Kane', 'Matt', 'Leo', 'Karthi', 'Will', 'Gowtham', 'Martin'] >>> name ['Petter', 'Scott', 'Kane', 'Matt', 'Leo', 'Karthi', 'Will', 'Gowtham', 'Martin'] >>> name = [] >>> name [] >>> name1.clear() >>> name1 []
ലിസ്റ്റ് ശൂന്യമാക്കുന്നതിനോ ലിസ്റ്റിൽ നിന്ന് ഒരു ഇനം നീക്കംചെയ്യുന്നതിനോ ലിസ്റ്റ് രീതികൾ ഉപയോഗിക്കുന്നതിനുപകരം, ഈ പ്രവർത്തനങ്ങൾ നടത്താൻ ഞങ്ങൾക്ക് ബിൽറ്റ് ഇൻ കീവേഡ് del ഉപയോഗിക്കാം. del കീവേഡിന് മെമ്മറിയിൽ നിന്ന് ഒരു ലിസ്റ്റ് ഒബ്uജക്റ്റ് ഇല്ലാതാക്കാനോ ഒരു ലിസ്റ്റിൽ നിന്ന് ഒരു ഇനം ഇല്ലാതാക്കാനോ ഒരു സ്ലൈസിൽ നിന്ന് ഒരു ഇനം ഇല്ലാതാക്കാനോ കഴിയും.
>>> name = ['Leo','Matt','Kane','Scott','Petter','Will'] >>> del name[0] >>> name ['Matt', 'Kane', 'Scott', 'Petter', 'Will'] >>> del name[-3:] >>> name ['Matt', 'Kane'] >>> del name[:] >>> name []
id() ഫംഗ്uഷനിൽ ബിൽറ്റ് ചെയ്uതത് ഒരു ഒബ്uജക്uറ്റിന്റെ \ഐഡന്റിറ്റി തിരികെ നൽകുന്നു. ഈ ഒബ്uജക്റ്റിന് അതിന്റെ ജീവിതകാലത്ത് അദ്വിതീയവും സ്ഥിരവുമായിരിക്കുമെന്ന് ഉറപ്പുനൽകുന്ന ഒരു പൂർണ്ണസംഖ്യയാണിത്.
>>> id(name) 139979929658824 >>> del name >>> id(name) Traceback (most recent call last): File "", line 1, in NameError: name 'name' is not defined
ശ്രദ്ധിക്കുക: del() ഉപയോഗിച്ച് ഞങ്ങൾ ലിസ്റ്റ് വേരിയബിൾ മെമ്മറിയിൽ നിന്ന് നീക്കംചെയ്തു, അതിനാൽ ഇത് നെയിം പിശക് നൽകുന്നു.
help() funtion:
ബിൽറ്റ്-ഇൻ ഹെൽപ്പ് function() ഒരു പ്രത്യേക വസ്തുവിനെ കുറിച്ചോ ആ വസ്തുവിന്റെ രീതികളെ കുറിച്ചോ ഉള്ള വിശദാംശങ്ങൾ ലഭിക്കാൻ വളരെ ഉപയോഗപ്രദമാണ്.
help(object) help(object.method)
ഈ ലേഖനത്തിൽ ഇതുവരെ, ലിസ്റ്റ് രീതികൾ ഉപയോഗിച്ച് ലിസ്റ്റ് ഒബ്uജക്റ്റുകൾ സംഭരിക്കാനും ആക്uസസ് ചെയ്യാനും പരിഷ്uക്കരിക്കാനും ഇല്ലാതാക്കാനും ഒരു ലിസ്റ്റ് ഡാറ്റ ഘടന എങ്ങനെ ഉപയോഗിക്കാമെന്ന് ഞങ്ങൾ കണ്ടു. വളരെ ഫലപ്രദമായ പ്രവർത്തനങ്ങളായ id(), dir(), type(), help() പോലുള്ള ചില ബിൽറ്റ്-ഇൻ ഫംഗ്uഷനുകളും ഞങ്ങൾ കണ്ടിട്ടുണ്ട്. പൈത്തണിൽ ഞങ്ങൾക്ക് ലിസ്റ്റ് കോംപ്രഹെൻഷനും ഉണ്ട്, അത് ഒരു ലിസ്റ്റ് സൃഷ്ടിക്കുന്നതിനുള്ള കൂടുതൽ സംക്ഷിപ്തവും വായിക്കാവുന്നതുമായ മാർഗം നൽകുന്നു.