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

URL: https://skillaria.top/ta/guides/python/spiski-python

Python-இல் பட்டியல் (list) என்பது சதுர அடைப்புக்குறியில் எழுதப்படும் வரிசையான, மாற்றக்கூடிய தொகுப்பு, எடுத்துக்காட்டாக [250, 1200, 99]: உறுப்புகளை append முறையால் சேர்க்கலாம், நுழைக்கலாம், நீக்கலாம், துண்டிப்புகளால் எடுக்கலாம், வரிசைப்படுத்தலாம். sort பட்டியலை அதே இடத்தில் வரிசைப்படுத்தி None தரும்; sorted புதிய வரிசைப்படுத்திய பட்டியலைத் தரும்.

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` வேண்டும்.

| முறை | என்ன செய்கிறது |
| --- | --- |

| `append(x)` | x-ஐ இறுதியில் சேர் |

| `extend(iter)` | வரிசையின் எல்லா உறுப்புகளையும் சேர் |

| `insert(i, x)` | குறியீடு i-க்கு முன் x-ஐ நுழை |

| `remove(x)` | x-இன் முதல் நிகழ்வை நீக்கு (இல்லையென்றால் ValueError) |

| `pop(i=-1)` | குறியீட்டில் உள்ள உறுப்பை நீக்கித் திருப்பு |

| `index(x)` | x-இன் முதல் நிகழ்வின் குறியீடு |

| `count(x)` | x எத்தனை முறை வருகிறது |

| `sort()` | அதே இடத்தில் வரிசைப்படுத்து |

| `reverse()` | அதே இடத்தில் தலைகீழாக்கு |

| `copy()` | மேலோட்ட நகல் |

| `clear()` | பட்டியலை வெறுமையாக்கு |

குறியீட்டால் அல்லது முழு வரம்பால் உறுப்புகளை `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!
```

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

| பணி | தொகுப்பு |
| --- | --- |

| வரிசை மற்றும் மாற்றங்கள் | `list` |

| நிலையான பதிவு | `tuple` |

| விசையால் தேடல் | `dict` |

| தனித்துவம், "இருக்கிறதா" சரிபார்ப்பு | `set` |

| மாற்ற முடியாத அமைப்புகள் | `frozendict` (Python 3.15) |

`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: பூஜ்ஜியத்திலிருந்து நிபுணர் வரை» பாடநெறியில் நடைமுறையில் விளக்கப்பட்டுள்ளன.

## FAQ

**Python-இல் பட்டியலுக்கும் array-க்கும் என்ன வேறுபாடு?**

மற்ற மொழிகளின் பொருளில் Python-இல் உள்ளமைவு array இல்லை; அந்த இடத்தை வெவ்வேறு வகை மதிப்புகளைச் சேமிக்கக்கூடிய பட்டியல் நிரப்புகிறது. சுருக்கமான எண் வரிசைகளுக்கு array தொகுதியும் NumPy நூலகமும் உண்டு.

**பட்டியலில் ஓர் உறுப்பின் குறியீட்டை எப்படிக் கண்டறிவது?**

a.index(x) முதல் நிகழ்வின் குறியீட்டைத் தரும்; உறுப்பு இல்லையென்றால் ValueError வீசும். அதனால் அழைப்புக்கு முன் x in a சரிபாருங்கள்.

**பட்டியலில் உள்ள நகல்களை வரிசை மாறாமல் எப்படி நீக்குவது?**

list(dict.fromkeys(a)) பயன்படுத்துங்கள்: அகராதி விசைகளை தனித்துவமாகவும் செருகிய வரிசையிலும் வைத்திருக்கும். list(set(a)) நகல்களை நீக்கும், ஆனால் வரிசையைப் பாதுகாக்காது.

**சரங்களின் பட்டியலை ஒரே சரமாக எப்படி இணைப்பது?**

சரத்தின் join முறை மூலம்: ", ".join(["a", "b", "c"]) "a, b, c" தரும். எல்லா உறுப்புகளும் சரங்களாக இருக்க வேண்டும்; எண்களை முதலில் map(str, a) மூலம் மாற்றுங்கள்.

**ஒரு பட்டியலில் வெவ்வேறு வகை உறுப்புகளை வைக்க முடியுமா?**

ஆம், பட்டியலில் எண்கள், சரங்கள், மற்ற பட்டியல்கள் மற்றும் எந்தப் பொருட்களையும் ஒரே நேரத்தில் வைக்கலாம். ஆனால் key இல்லாமல் அத்தகைய பட்டியலை வரிசைப்படுத்த முடியாது — எண்ணையும் சரத்தையும் ஒப்பிட்டால் TypeError வரும்.


---
Source: Skillaria.Top (https://skillaria.top)