Python-இல் பட்டியல்கள் (list): முறைகள், துண்டிப்புகள், வரிசைப்படுத்தல், append, tuple மற்றும் set

Python-இல் பட்டியல் (list) என்பது சதுர அடைப்புக்குறியில் உள்ள, வரிசையான, மாற்றக்கூடிய எந்த மதிப்புகளின் தொகுப்பு: உறுப்புகளை இறுதியில் சேர்க்கலாம், நடுவில் நுழைக்கலாம், நீக்கலாம், வரிசைப்படுத்தலாம். இதுவே மொழியின் மிகப் பயன்படும் தொகுப்பு: கோப்பின் வரிகள், மாதச் செலவுகள், API பதில்கள் — பெரும்பாலானவை பட்டியலிலிருந்தே தொடங்குகின்றன. Python list முழுவதையும் பார்ப்போம்: உருவாக்குதல், முறைகள், துண்டிப்புகள், வரிசைப்படுத்தல், பட்டியல் உருவாக்கல், நகலெடுத்தல், இறுதியில் tuple மற்றும் set.

Python-இல் பட்டியல் என்றால் என்ன

பட்டியல் உறுப்புகளை நீங்கள் கொடுத்த வரிசையில் வைத்திருக்கும்; பூஜ்ஜியத்திலிருந்து தொடங்கும் குறியீட்டால் அணுகலாம். ஒரே பட்டியலில் வெவ்வேறு வகை மதிப்புகள் இருக்கலாம், ஆனால் நடைமுறையில் பொதுவாக ஒரே வகைத் தரவையே சேமிக்கிறோம்.

amounts = [250, 1200, 99]
print(amounts[0])     # 250 — முதல் உறுப்பு
print(amounts[-1])    # 99 — கடைசி உறுப்பு
amounts[1] = 1300     # பட்டியல் மாற்றக்கூடியது
print(len(amounts))   # 3 — பட்டியலின் நீளம்

பட்டியலின் அளவை len() செயல்பாடு தரும். இல்லாத குறியீட்டை அணுகினால் IndexError: list index out of range வரும்.

பட்டியல் உருவாக்குதல்

empty = []                       # வெற்றுப் பட்டியல்
also_empty = list()              # அதே, list செயல்பாட்டால்
nums = [1, 2, 3]
chars = list("abc")              # ['a', 'b', 'c']
digits = list(range(5))          # [0, 1, 2, 3, 4]
zeros = [0] * 4                  # [0, 0, 0, 0]

list() செயல்பாடு எந்த மீண்டும் சுற்றக்கூடிய பொருளையும் பட்டியலாக மாற்றும்: சரம், range, set, அகராதியின் விசைகள்.

append மற்றும் பிற பட்டியல் முறைகள்

append ஒரு உறுப்பை பட்டியலின் இறுதியில் சேர்க்கிறது — Python-இல் மிகவும் பொதுவான முறை. அது பட்டியலை அதே இடத்தில் மாற்றி None தரும்.

amounts = [250, 1200]
amounts.append(450)          # [250, 1200, 450]
amounts.extend([10, 20])     # [250, 1200, 450, 10, 20]
amounts.insert(0, 5)         # [5, 250, 1200, 450, 10, 20]
amounts.remove(1200)         # முதல் 1200 மதிப்பை நீக்கு
last = amounts.pop()         # 20 — கடைசியை நீக்கி திருப்பு

பொதுவான தவறு: a.append([10, 20]) ஒரே உறுப்பைச் சேர்க்கும் — உள்ளே ஒரு பட்டியல், இரண்டு எண்கள் அல்ல. பல உறுப்புகளுக்கு extend வேண்டும்.

குறியீட்டால் அல்லது முழு வரம்பால் உறுப்புகளை del இயக்கியாலும் நீக்கலாம்: del a[0], del a[1:3]. பட்டியல்களுக்கான பயனுள்ள உள்ளமைவுச் செயல்பாடுகள்: len, sum, min, max, sorted, reversed, enumerate, zip.

Python-இல் துண்டிப்புகள் (slices)

துண்டிப்பு பட்டியலின் ஒரு பகுதியை a[start:stop:step] வடிவத்தில் எடுக்கும்: start உட்பட, stop தவிர, step படியுடன். எந்தப் பகுதியையும் விடலாம். துண்டிப்பு எப்போதும் புதிய பட்டியலைத் தரும்.

a = [0, 1, 2, 3, 4, 5]
print(a[1:4])     # [1, 2, 3]
print(a[:2])      # [0, 1] — முதல் இரண்டு
print(a[-2:])     # [4, 5] — கடைசி இரண்டு
print(a[::2])     # [0, 2, 4] — ஒவ்வொரு இரண்டாவது
print(a[::-1])    # [5, 4, 3, 2, 1, 0] — தலைகீழ்
print(a[:])       # முழு பட்டியலின் நகல்

குறியீட்டைப் போலன்றி, பட்டியலுக்கு வெளியே உள்ள துண்டிப்பு பிழை தராது: a[10:20] வெறும் [] தரும். துண்டிப்புக்கு மதிப்பை ஒதுக்கி பட்டியலின் ஒரு பகுதியை மாற்றலாம்: a[1:3] = ["x", "y", "z"].

சரத்தின் துண்டிப்பு

துண்டிப்புகள் எந்தத் தொடருக்கும் ஒரே மாதிரி வேலை செய்யும், சரங்கள் மற்றும் tuple-களுக்கும் உட்பட:

s = "Python 3.15"
print(s[:6])      # Python
print(s[-4:])     # 3.15
print(s[::-1])    # 51.3 nohtyP

சரத்தை துண்டிப்பால் மாற்ற முடியாது — சரங்கள் மாற்ற முடியாதவை; துண்டிப்பு புதிய சரத்தை உருவாக்கும்.

பட்டியலை வரிசைப்படுத்துதல்: sort மற்றும் sorted

தொடக்கநிலையாளர்கள் அதிகம் குழம்பும் இடம் இது. sort முறை உறுப்புகளை பட்டியலுக்குள்ளேயே மறுவரிசைப்படுத்தி None தரும். sorted செயல்பாடு மூல பட்டியலைத் தொடாமல், புதிய வரிசைப்படுத்திய பட்டியலைத் தரும்.

amounts = [250, 1200, 99]
amounts.append(450)
print(sorted(amounts))     # [99, 250, 450, 1200] — புதிய நகல்
print(amounts)             # [250, 1200, 99, 450] — மூலம் அப்படியே

result = amounts.sort()    # அதே இடத்தில் வரிசைப்படுத்து
print(result, amounts)     # None [99, 250, 450, 1200]

இங்கிருந்து "ஏன் என்னிடம் None?" என்ற உன்னதப் பிழை: a = a.sort() பட்டியலை None மதிப்பால் அழித்துவிடும். a.sort() அல்லது a = sorted(a) — இரண்டில் ஒன்றை மட்டும் எழுதுங்கள்.

விசையும் தலைகீழ் வரிசையும்

இரண்டும் key மற்றும் reverse அளவுருக்களை ஏற்கும். key ஒரு செயல்பாடு: அதன் முடிவால் உறுப்புகள் ஒப்பிடப்படும்.

words = ["காபி", "டாக்ஸி", "சந்தா"]
print(sorted(words, key=len))               # ['காபி', 'டாக்ஸி', 'சந்தா']
print(sorted(words, key=str.lower))         # பெரிய சிறிய எழுத்தைப் பொருட்படுத்தாமல்
print(sorted([3, 1, 2], reverse=True))      # [3, 2, 1]

expenses = [("உணவு", 650), ("சினிமா", 120), ("டாக்ஸி", 300)]
expenses.sort(key=lambda e: e[1])           # தொகையின்படி

Python-இன் வரிசைப்படுத்தல் நிலையானது: ஒரே விசையுடைய உறுப்புகள் அசல் வரிசையைத் தக்கவைக்கும். வேறுபாடு பயன்பாட்டிலும் உண்டு: sorted எந்த வரிசையையும் ஏற்கும் (சரம், அகராதி, set), ஆனால் sort பட்டியல்களுக்கு மட்டுமே.

பட்டியலைத் தலைகீழாக்குதல்

வெவ்வேறு நடத்தை கொண்ட மூன்று வழிகள்:

• a.reverse() — அதே இடத்தில் தலைகீழாக்கும், None தரும்;
• a[::-1] — தலைகீழாக்கிய புதிய பட்டியல்;
• reversed(a) — சோம்பேறி iterator, சுழலில் வசதியானது: for x in reversed(a):.

பட்டியலில் சுழல்

items = ["காபி", "மெட்ரோ", "சினிமா"]
for item in items:
    print(item)

for i, item in enumerate(items, start=1):
    print(i, item)          # 1 காபி, 2 மெட்ரோ, 3 சினிமா

print("சினிமா" in items)    # True — உறுப்பு இருக்கிறதா என்று சரிபார்ப்பு

எந்தப் பட்டியலின் மீது சுழல் செல்கிறதோ அதிலிருந்து உறுப்புகளை நீக்காதீர்கள் — சில உறுப்புகள் தவறவிடப்படும். பட்டியல் உருவாக்கல் மூலம் புதிய பட்டியலை உருவாக்குங்கள் அல்லது நகல் a[:]-இன் மீது சுற்றுங்கள்.

பட்டியல் உருவாக்கல் (list comprehension)

பட்டியல் உருவாக்கல் புதிய பட்டியலை ஒரே வரியில் கட்டும்: ஒரு வெளிப்பாடு, ஒரு சுழல், விருப்ப நிபந்தனை.

squares = [n * n for n in range(6)]          # [0, 1, 4, 9, 16, 25]
big = [a for a in [250, 1200, 99] if a > 200]  # [250, 1200]
names = [s.strip().title() for s in [" அன்னா ", "ஓலெக்"]]

பட்டியல் உருவாக்கல் பொதுவாக append கொண்ட சுழலை விட வேகமானதும் படிக்க எளிதானதும். ஆனால் தர்க்கம் ஒரு தெளிவான வரியில் அடங்கவில்லை என்றால் சாதாரண சுழலே சிறந்தது.

பட்டியல்களை இணைத்தல், கூட்டுதல் மற்றும் கழித்தல்

a = [1, 2, 3]
b = [3, 4]
print(a + b)       # [1, 2, 3, 3, 4] — புதிய பட்டியல்
a += b             # a.extend(b) போன்றது
print([*a, *b])    # unpacking மூலம் புதிய பட்டியல்

பட்டியல்களைக் கழிக்க - இயக்கி இல்லை. ஒரு பட்டியலிலிருந்து மற்றொன்றின் உறுப்புகளை நீக்க பட்டியல் உருவாக்கல் பயன்படுத்துங்கள்: [x for x in a if x not in set(b)]. பொதுவான உறுப்புகளை set மூலம் கண்டறிவது எளிது: set(a) & set(b) (வரிசையும் நகல்களும் இழக்கப்படும்).

உள்ளமை மற்றும் இரு-பரிமாண பட்டியல்கள்

பட்டியல்களின் பட்டியல் அட்டவணையையோ அணியையோ (matrix) சேமிக்க எளிய வழி:

matrix = [[1, 2, 3], [4, 5, 6]]
print(matrix[1][2])     # 6
grid = [[0] * 3 for _ in range(2)]   # சரியானது
bad = [[0] * 3] * 2                  # பொறி: ஒரே பட்டியலுக்கு இரண்டு குறிப்புகள்
bad[0][0] = 9
print(bad)              # [[9, 0, 0], [9, 0, 0]]

பட்டியலை unpacking செய்தல்

first, second, third = [10, 20, 30]
head, *rest = [1, 2, 3, 4]      # head=1, rest=[2, 3, 4]
print(*["a", "b"], sep=", ")    # a, b — பட்டியலை அடைப்பில்லாமல் அச்சிடு

மாறிகளின் எண்ணிக்கை பட்டியலின் நீளத்துடன் பொருந்தாவிட்டால் ValueError வரும் — நட்சத்திரக்குறி உதவும்.

பட்டியலை நகலெடுத்தல்

b = a பட்டியலை நகலெடுப்பதில்லை; அதே பொருளுக்கு இரண்டாவது பெயரைத் தருகிறது: b வழியான மாற்றங்கள் a-வில் தெரியும். சுயாதீன நகலை வெளிப்படையாக உருவாக்குங்கள்: a.copy(), list(a) அல்லது a[:]. உள்ளமை தரவுக்கு இது போதாது — உள் பட்டியல்கள் பகிரப்பட்டே இருக்கும்; copy.deepcopy(a) தேவை.

import copy
a = [[1, 2], [3]]
b = a.copy()
b[0].append(99)
print(a)                 # [[1, 2, 99], [3]] — உள் பட்டியல் பகிரப்பட்டது
c = copy.deepcopy(a)     # முழுமையாக சுயாதீன நகல்

Tuple: மாற்ற முடியாத பட்டியல்

Tuple (tuple) பட்டியலைப் போன்றது, ஆனால் உருவாக்கிய பின் மாற்ற முடியாது. அது வாசகருக்கான தெளிவான சமிக்ஞை: இது வளரும் தொகுப்பு அல்ல, நிலையான புலங்களைக் கொண்ட ஒரு பதிவு. Tuple-களை எளிதாகப் பிரிக்கலாம்; செயல்பாடுகள் பல மதிப்புகளைத் திருப்பித் தருவது அவற்றின் மூலம்தான்.

expense = (250, "காபி")
amount, item = expense
expense[0] = 300
# TypeError: 'tuple' object does not support item assignment

மாற்ற முடியாத மதிப்புகள் கொண்ட tuple ஹாஷ் செய்யக்கூடியது, அதனால் அகராதியின் விசையாகப் பயன்படும். ஒரே உறுப்பு கொண்ட tuple-க்கு காற்புள்ளி தேவை: (5,).

Set: தனித்துவமானவை மட்டும்

Set (set) தனித்துவமான மதிப்புகளை மட்டுமே சேமிக்கும்; வரிசையை நினைவில் வைக்காது. நகல்களை அகற்றவும், "இப்படி ஒன்று இருக்கிறதா" என்று சரிபார்க்கவும் இதுவே வேகமான வழி; மேலும் அது பொதுவானது, வேறுபாடு, ஒன்றிணைப்பு ஆகியவற்றையும் செய்யும்.

jan = {"உணவு", "டாக்ஸி", "சினிமா"}
feb = {"உணவு", "சந்தாக்கள்"}
print(jan & feb)    # {'உணவு'}
print(feb - jan)    # {'சந்தாக்கள்'}
unique = list(dict.fromkeys([3, 1, 3, 2]))   # [3, 1, 2] — நகல்கள் இல்லை, வரிசை பாதுகாக்கப்பட்டது
empty = set()       # {} — இது வெற்று dict!

எந்தத் தொகுப்பைத் தேர்ந்தெடுப்பது

x in list உறுப்புகளை ஒவ்வொன்றாகச் சரிபார்க்கும், ஆனால் x in set கிட்டத்தட்ட உடனே வேலை செய்யும். சுழலில் பெரிய பட்டியலில் பலமுறை உறுப்பைத் தேடுகிறீர்கள் என்றால் அதை set-ஆக மாற்றுங்கள்.

சுருக்கம்

Python list என்பது வரிசையான, மாற்றக்கூடிய தொகுப்பு: append மற்றும் extend சேர்க்கும், pop மற்றும் remove நீக்கும், a[start:stop:step] துண்டிப்புகள் பகுதிகளை எடுக்கும், sort அதே இடத்தில் வரிசைப்படுத்தி None தரும், sorted புதிய பட்டியலைத் தரும். நகலை வெளிப்படையாக உருவாக்குங்கள்; நிலையான பதிவுகளுக்கு tuple, தனித்துவமான மதிப்புகளுக்கு set. பட்டியல்கள், tuple-கள், அகராதிகள் மற்றும் set-கள் «Python 3.15: பூஜ்ஜியத்திலிருந்து நிபுணர் வரை» பாடநெறியில் நடைமுறையில் விளக்கப்பட்டுள்ளன.