# Python cheat sheet: தொடரமைப்பு, கட்டளைகள் மற்றும் உள்ளமைந்த செயற்கூறுகள் அட்டவணைகளில்

URL: https://skillaria.top/ta/guides/python/python-cheat-sheet

Python தொடரமைப்பு உள்ளீடுகளுக்குப் பதிலாக உள்தள்ளல்களால் தொகுதிகளை வரையறுக்கிறது: இரு புள்ளிக்குப் பிறகு வரும் தொகுதி 4 இடைவெளிகளால் உள்தள்ளப்படுகிறது. அடிப்படை: வகை அறிவிப்பு இல்லாத மாறிகள், if/elif/else நிபந்தனைகள், for மற்றும் while சுழல்கள், def செயற்கூறுகள், அத்துடன் print, len, range, input, type போன்ற உள்ளமைந்த செயற்கூறுகளும் சரம், பட்டியல், அகராதி முறைகளும்.

இந்த Python cheat sheet முதல் சில மாதங்களில் கையில் வைத்திருக்க வேண்டிய அனைத்தையும் ஒரே பக்கத்தில் தொகுக்கிறது: Python தொடரமைப்பு, சுழல்கள், உள்ளமைந்த செயற்கூறுகள், சரம், பட்டியல் மற்றும் அகராதி முறைகள், டெர்மினல் கட்டளைகள். ஒவ்வொரு அட்டவணையும் வேலை செய்யும் எடுத்துக்காட்டுகளுடன் கூடிய குறுகிய குறிப்பேடு — அவற்றை நேரடியாக REPL-இல் ஒட்டலாம்.

## Python தொடரமைப்பின் அடிப்படைகள்

முக்கிய அம்சம் — தொகுதிகள் அடைப்புக்குறிகளால் அல்ல, உள்தள்ளல்களால் குறிக்கப்படுகின்றன. இரு புள்ளியுள்ள வரிக்குப் பின் (`if`, `for`, `def`, `class`) வரும் வரிகள் 4 இடைவெளிகளால் உள்தள்ளப்படுகின்றன. Tab மற்றும் இடைவெளிகளைக் கலக்கக் கூடாது — `IndentationError` வரும்.

| கட்டமைப்பு | எடுத்துக்காட்டு | விளக்கம் |
| --- | --- | --- |

| கருத்துரை | `# உரை` | # முதல் வரியின் இறுதி வரை உள்ள அனைத்தும் புறக்கணிக்கப்படுகின்றன |

| மாறி | `age = 25` | வகை அறிவிக்கப்படுவதில்லை, அதை மதிப்பே தீர்மானிக்கிறது |

| பல ஒதுக்கல் | `a, b = 1, 2` | அன்பேக்கிங்; மதிப்புகளை மாற்றுதல்: `a, b = b, a` |

| வெளியீடு | `print("வணக்கம்", name)` | வாதங்கள் இடைவெளியால் பிரிக்கப்படுகின்றன |

| உள்ளீடு | `s = input("பெயர்: ")` | எப்போதும் சரத்தைத் தருகிறது |

| f-சரம் | `f"{name}: {price:.2f}"` | வெளிப்பாடுகளின் பதிலீடு மற்றும் வடிவம் |

| வகை குறிப்பு | `count: int = 0` | IDE-க்கும் சரிபார்ப்பிகளுக்கும் குறிப்பு, இயக்கத்தின்போது சரிபார்க்கப்படுவதில்லை |

| வெற்றுத் தொகுதி | `pass` | தொடரமைப்பு உடல் கேட்கும் இடத்தில் காலியிடம் |

| இறக்குமதி | `from math import sqrt` | தொகுதி அல்லது அதிலிருந்து ஒரு பெயரை இணைத்தல் |

### தரவு வகைகள்

| வகை | மாறிலி (literal) | மாற்றக்கூடியது |
| --- | --- | --- |

| `int` | `42`, `1_000_000` | இல்லை |

| `float` | `3.14`, `1e-3` | இல்லை |

| `bool` | `True`, `False` | இல்லை |

| `str` | `"உரை"`, `'உரை'`, `"""பல வரிகள்"""` | இல்லை |

| `list` | `[1, 2, 3]` | ஆம் |

| `tuple` | `(1, 2)`, `(1,)` | இல்லை |

| `dict` | `{"a": 1}` | ஆம் |

| `set` | `{1, 2}`, வெற்று — `set()` | ஆம் |

| `NoneType` | `None` | — |

### Operators

| குழு | Operators | எடுத்துக்காட்டு → முடிவு |
| --- | --- | --- |

| கணிதம் | `+ - * / // % **` | `7 // 2` → 3, `7 % 2` → 1, `2 ** 10` → 1024 |

| ஒப்பீடு | `== != < > <= >=` | `1 < x < 10` — ஒப்பீட்டுச் சங்கிலி |

| தர்க்கம் | `and or not` | `x or "இயல்புநிலை"` |

| உறுப்பினர் | `in`, `not in` | `"a" in "abc"` → True |

| அடையாளம் | `is`, `is not` | `x is None` |

| ஒதுக்கல் | `+= -= *= /=`, `:=` | `if (n := len(s)) > 10: ...` |

## நிபந்தனைகள் மற்றும் பொருத்துதல்

```
if score >= 90:
    grade = "A"
elif score >= 70:
    grade = "B"
else:
    grade = "C"

status = "வயது வந்தவர்" if age >= 18 else "குழந்தை"   # மும்மை operator

match command:
    case "start":
        print("தொடக்கம்")
    case "stop" | "exit":
        print("நிறுத்தம்")
    case _:
        print("தெரியாத கட்டளை")
```

பொய்யானவையாகக் கருதப்படுபவை: `False`, `None`, `0`, வெற்றுச் சரம் மற்றும் வெற்றுத் தொகுப்புகள். அதனால் `if len(items) > 0`-க்குப் பதிலாக வெறுமனே `if items` என்று எழுதுகிறார்கள்.

## Python சுழல்கள்: for மற்றும் while தொடரமைப்பு

### for சுழல்

Python for சுழலின் தொடரமைப்பு: `for மாறி in தொடர்:` மற்றும் உள்தள்ளப்பட்ட உடல். சுழல் எந்த மீண்டுசெய்யக்கூடிய பொருளையும் — சரம், பட்டியல், அகராதி, கோப்பு, `range` — வரிசையாகச் செல்கிறது.

```
for i in range(5):              # 0 1 2 3 4
    print(i)

for i in range(10, 0, -2):      # 10 8 6 4 2
    print(i)

for i, fruit in enumerate(["ஆப்பிள்", "பேரி"], start=1):
    print(i, fruit)

for name, score in zip(names, scores):
    print(name, score)

for key, value in prices.items():
    print(key, value)
```

### while சுழல்

```
attempts = 3
while attempts > 0:
    password = input("கடவுச்சொல்: ")
    if password == "secret":
        print("உள்நுழைவு வெற்றி")
        break
    attempts -= 1
else:
    print("முயற்சிகள் தீர்ந்தன")   # break இல்லாமல் முடிந்தால் இயங்கும்
```

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

| `break` | சுழலிலிருந்து முன்கூட்டியே வெளியேறுகிறது |

| `continue` | அடுத்த மீண்டுசெய்தலுக்குச் செல்கிறது |

| சுழலின் `else` | `break` இல்லாமல் சுழல் முடிந்தால் இயங்குகிறது |

| `range(stop)`, `range(start, stop, step)` | எண்களின் தொடர்; `stop` சேர்க்கப்படுவதில்லை |

### பட்டியல் comprehension-கள்

```
squares = [x ** 2 for x in range(10)]
evens = [x for x in numbers if x % 2 == 0]
lengths = {word: len(word) for word in words}
unique = {c.lower() for c in text}
total = sum(x * x for x in range(100))   # உருவாக்கி வெளிப்பாடு (generator expression)
```

## செயற்கூறுகள்

```
def greet(name: str, greeting: str = "வணக்கம்") -> str:
    """வாழ்த்துச் சரத்தைத் தருகிறது."""
    return f"{greeting}, {name}!"

def total(*args, **kwargs):
    return sum(args), kwargs

square = lambda x: x * x
print(greet("அன்னா"))                 # வணக்கம், அன்னா!
print(greet("அன்னா", greeting="ஹாய்"))  # ஹாய், அன்னா!
```

| கூறு | பொருள் |
| --- | --- |

| `def f(a, b=1)` | இயல்புநிலை மதிப்புள்ள அளவுரு |

| `*args` | எத்தனை நிலை வாதங்களும் (tuple) |

| `**kwargs` | எத்தனை பெயரிட்ட வாதங்களும் (அகராதி) |

| `return` | மதிப்பைத் திருப்புகிறது; இது இல்லாவிட்டால் செயற்கூறு `None` தரும் |

| `lambda x: ...` | ஒரு வெளிப்பாட்டில் உள்ள குறுகிய பெயரில்லாத செயற்கூறு |

| `global`, `nonlocal` | வெளிப்புறப் பரப்பிலிருந்து மாறியை மாற்றுதல் |

`def f(items=[])` போன்ற மாற்றக்கூடிய இயல்புநிலை மதிப்பைப் பயன்படுத்த வேண்டாம்: பட்டியல் ஒருமுறை மட்டுமே உருவாக்கப்பட்டு அழைப்புகளுக்கு இடையே சேர்ந்துகொண்டே போகும். சரியானது — `items=None` மற்றும் உள்ளே `if items is None: items = []`.

## Python உள்ளமைந்த செயற்கூறுகள்

Python உள்ளமைந்த செயற்கூறுகள் இறக்குமதி இல்லாமலேயே கிடைக்கின்றன. கிட்டத்தட்ட ஒவ்வொரு ஸ்கிரிப்ட்டிலும் வரும் முக்கிய செயற்கூறுகள் இவை.

| செயற்கூறு | என்ன செய்கிறது | எடுத்துக்காட்டு → முடிவு |
| --- | --- | --- |

| `print()` | மதிப்புகளை வெளியிடுகிறது | `print(1, 2, sep="-")` → 1-2 |

| `input()` | விசைப்பலகையிலிருந்து சரத்தைப் படிக்கிறது | `int(input())` |

| `len()` | தொகுப்பு அல்லது சரத்தின் நீளம் | `len("abc")` → 3 |

| `type()` | பொருளின் வகை | `type(3.0)` → <class 'float'> |

| `isinstance()` | வகை சரிபார்ப்பு | `isinstance(5, int)` → True |

| `int() float() str() bool()` | வகை மாற்றம் | `int("42")` → 42 |

| `list() tuple() set() dict()` | தொகுப்புகளை உருவாக்குதல் | `list("ab")` → ['a', 'b'] |

| `range()` | எண்களின் வரம்பு | `list(range(3))` → [0, 1, 2] |

| `enumerate()` | (குறியீடு, உறுப்பு) ஜோடிகள் | `list(enumerate("ab"))` → [(0, 'a'), (1, 'b')] |

| `zip()` | வரிசைகளை ஜோடி ஜோடியாக இணைக்கிறது | `list(zip([1, 2], "ab"))` → [(1, 'a'), (2, 'b')] |

| `sum() min() max()` | கூட்டுத்தொகை, குறைந்தபட்சம், அதிகபட்சம் | `max([3, 7, 1])` → 7 |

| `abs() round()` | முழுமதிப்பு மற்றும் வட்டமிடுதல் | `round(3.14159, 2)` → 3.14 |

| `sorted()` | புதிய வரிசைப்படுத்திய பட்டியல் | `sorted(words, key=len, reverse=True)` |

| `reversed()` | தலைகீழ் வரிசையில் iterator | `list(reversed([1, 2]))` → [2, 1] |

| `map() filter()` | செயற்கூறைப் பயன்படுத்துதல் / வடிகட்டுதல் | `list(map(str, [1, 2]))` → ['1', '2'] |

| `any() all()` | குறைந்தது ஒன்று / அனைத்தும் உண்மை | `all(x > 0 for x in nums)` |

| `open()` | கோப்பைத் திறக்கிறது | `open("a.txt", encoding="utf-8")` |

| `help() dir()` | உதவி மற்றும் பண்புக்கூறுகளின் பட்டியல் | `help(str.split)`, `dir(list)` |

| `id() hash()` | பொருளின் அடையாளம் மற்றும் hash | `hash("a")` |

எப்போதும் கையில் இருக்கும் சிறந்த Python குறிப்பேடு — REPL-இல் `help()` செயற்கூறு: `help(dict)` அகராதியின் அனைத்து முறைகளையும் விளக்கத்துடன் காட்டும், `dir(obj)` — கிடைக்கும் பெயர்களின் பட்டியல்.

## சர முறைகள்

Python சரங்களின் தொடரமைப்பு: சரம் மாற்ற முடியாதது, ஒவ்வொரு முறையும் புதிய சரத்தைத் தருகிறது. துண்டுகள் (slices) பட்டியல்களைப் போலவே வேலை செய்கின்றன: `s[1:4]`, `s[::-1]` — தலைகீழாக்கல்.

| முறை | எடுத்துக்காட்டு → முடிவு |
| --- | --- |

| `upper() lower()` | `"Py".upper()` → 'PY' |

| `capitalize() title()` | `"hello world".title()` → 'Hello World' |

| `strip() lstrip() rstrip()` | `" hi \n".strip()` → 'hi' |

| `split(sep)` | `"a,b,c".split(",")` → ['a', 'b', 'c'] |

| `join(iterable)` | `"-".join(["a", "b"])` → 'a-b' |

| `replace(old, new)` | `"பூனை".replace("ப", "ம")` → 'மூனை' |

| `find() index()` | `"hello".find("l")` → 2; இல்லையென்றால் -1 (`index`-க்கு — பிழை) |

| `count()` | `"banana".count("a")` → 3 |

| `startswith() endswith()` | `"file.py".endswith(".py")` → True |

| `isdigit() isalpha() isspace()` | `"123".isdigit()` → True |

| `removeprefix() removesuffix()` | `"test_a".removeprefix("test_")` → 'a' |

| `zfill() center() ljust()` | `"7".zfill(3)` → '007' |

| `format()` | `"{} + {}".format(1, 2)` → '1 + 2' |

## Python பட்டியல் கட்டளைகள்

பட்டியல் — மாற்றக்கூடிய, வரிசையான தொகுப்பு. பெரும்பாலான முறைகள் பட்டியலை அதே இடத்தில் மாற்றி `None` தருகின்றன, அதனால் `a = a.sort()` ஒரு பொதுவான தவறு.

| செயல் | என்ன செய்கிறது | எடுத்துக்காட்டு |
| --- | --- | --- |

| `append(x)` | இறுதியில் சேர்க்கிறது | `a.append(4)` |

| `extend(iter)` | அனைத்து உறுப்புகளையும் சேர்க்கிறது | `a.extend([5, 6])` |

| `insert(i, x)` | குறியீட்டின்படி செருகுகிறது | `a.insert(0, "first")` |

| `remove(x)` | மதிப்பின் முதல் நிகழ்வை நீக்குகிறது | `a.remove(3)` |

| `pop(i)` | உறுப்பை நீக்கி திருப்புகிறது (இயல்பாக கடைசியானது) | `last = a.pop()` |

| `clear()` | பட்டியலைக் காலியாக்குகிறது | `a.clear()` |

| `index(x)` | முதல் நிகழ்வின் குறியீடு | `a.index("b")` |

| `count(x)` | நிகழ்வுகளின் எண்ணிக்கை | `a.count(1)` |

| `sort()` | அதே இடத்தில் வரிசைப்படுத்துகிறது | `a.sort(key=str.lower)` |

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

| `copy()` | மேலோட்டமான நகல் | `b = a.copy()` |

| `del a[i]` | குறியீடு அல்லது துண்டால் நீக்குதல் | `del a[1:3]` |

| துண்டுகள் | `a[start:stop:step]` | `a[-1]` — கடைசியானது, `a[:3]` — முதல் மூன்று |

## Python அகராதி கட்டளைகள்

| செயல் | என்ன செய்கிறது | எடுத்துக்காட்டு |
| --- | --- | --- |

| `d[key]` | விசையின் மதிப்பு, விசை இல்லையென்றால் — `KeyError` | `d["name"]` |

| `get(key, default)` | மதிப்பு அல்லது மாற்று மதிப்பு | `d.get("age", 0)` |

| `d[key] = value` | சேர்க்கிறது அல்லது மாற்றுகிறது | `d["city"] = "சென்னை"` |

| `keys() values() items()` | விசைகள், மதிப்புகள், ஜோடிகள் | `for k, v in d.items():` |

| `update()` | மற்றொரு அகராதியுடன் இணைக்கிறது | `d.update({"a": 1})` |

| `d1 | d2` | இணைக்கப்பட்ட புதிய அகராதி | `merged = defaults | user` |

| `pop(key, default)` | நீக்கி மதிப்பைத் திருப்புகிறது | `d.pop("tmp", None)` |

| `popitem()` | கடைசியாகச் சேர்த்த ஜோடியை நீக்குகிறது | `d.popitem()` |

| `setdefault(key, value)` | மதிப்பைத் திருப்புகிறது, விசை இல்லையென்றால் உருவாக்குகிறது | `d.setdefault("tags", []).append("py")` |

| `key in d` | விசை உள்ளதா என்று சரிபார்த்தல் | `if "name" in d:` |

| `dict.fromkeys()` | ஒரே மதிப்புடன் விசைகளிலிருந்து அகராதி | `dict.fromkeys("abc", 0)` |

| `len(d)`, `del d[key]` | அளவு மற்றும் நீக்குதல் | `del d["old"]` |

### Tuple-கள் மற்றும் set-கள்

| செயல் | எடுத்துக்காட்டு → முடிவு |
| --- | --- |

| Tuple அன்பேக்கிங் | `x, y = (3, 4)` |

| Set-இல் சேர்த்தல் | `s.add(5)`, நீக்க — `s.discard(5)` |

| இணைப்பு / வெட்டுப்பகுதி | `{1, 2} | {2, 3}` → {1, 2, 3}; `{1, 2} & {2, 3}` → {2} |

| வித்தியாசம் | `{1, 2} - {2}` → {1} |

| பட்டியலிலிருந்து நகல்களை நீக்குதல் | `list(dict.fromkeys(items))` — வரிசையைப் பேணுகிறது |

## விதிவிலக்குகள் மற்றும் கோப்புகள்

```
try:
    number = int(input("எண்: "))
except ValueError as err:
    print("இது எண் அல்ல:", err)
else:
    print("வெற்றி")
finally:
    print("எப்போதும் இயங்கும்")

with open("data.txt", "w", encoding="utf-8") as f:
    f.write("வரி\n")

with open("data.txt", encoding="utf-8") as f:
    for line in f:
        print(line.rstrip())
```

| விதிவிலக்கு | எப்போது எழுகிறது |
| --- | --- |

| `SyntaxError`, `IndentationError` | தொடரமைப்பு அல்லது உள்தள்ளலில் பிழை |

| `NameError` | பெயர் வரையறுக்கப்படவில்லை (எழுத்துப் பிழை) |

| `TypeError` | பொருத்தமற்ற வகையுடன் செயல்: `"1" + 1` |

| `ValueError` | சரியான வகை, ஆனால் தவறான மதிப்பு: `int("abc")` |

| `IndexError`, `KeyError` | அத்தகைய குறியீடு அல்லது விசை இல்லை |

| `FileNotFoundError` | கோப்பு கிடைக்கவில்லை |

| `ZeroDivisionError` | பூஜ்ஜியத்தால் வகுத்தல் |

## வகுப்புகள்

```
from dataclasses import dataclass

class Dog:
    def __init__(self, name: str):
        self.name = name

    def bark(self) -> str:
        return f"{self.name}: லொள்!"

@dataclass
class Point:
    x: float
    y: float

print(Dog("ஷாரிக்").bark())   # ஷாரிக்: லொள்!
print(Point(1, 2))           # Point(x=1, y=2)
```

## Python உள்ளமைந்த தொகுதிகள்

நிலையான நூலகம் இன்டர்ப்ரெட்டருடன் நிறுவப்படுகிறது — `import` மட்டுமே போதும.

| தொகுதி | எதற்கு | எடுத்துக்காட்டு |
| --- | --- | --- |

| `math` | கணிதம் | `math.sqrt(16)` → 4.0 |

| `random` | சீரற்ற எண்கள் | `random.randint(1, 6)`, `random.choice(items)` |

| `datetime` | தேதி மற்றும் நேரம் | `datetime.date.today()` |

| `pathlib` | பாதைகள் மற்றும் கோப்புகள் | `Path("data").glob("*.csv")` |

| `os`, `sys` | அமைப்பு, சூழல் மாறிகள், வாதங்கள் | `os.environ.get("HOME")`, `sys.argv` |

| `json` | JSON-ஐப் படித்தல் மற்றும் எழுதுதல் | `json.loads(text)`, `json.dumps(obj, ensure_ascii=False)` |

| `csv` | CSV அட்டவணைகள் | `csv.DictReader(f)` |

| `collections` | Counter, defaultdict, deque | `Counter("banana").most_common(1)` → [('a', 3)] |

| `itertools` | iterator-களின் சேர்க்கைகள் மற்றும் சங்கிலிகள் | `itertools.chain(a, b)` |

| `re` | வழக்கமான வெளிப்பாடுகள் (regular expressions) | `re.findall(r"\d+", s)` |

| `time` | இடைநிறுத்தங்கள் மற்றும் நேர அளவீடு | `time.sleep(1)`, `time.perf_counter()` |

| `asyncio` | ஒத்திசைவற்ற குறியீடு | `asyncio.run(main())` |

Python 3.15-இல் lazy import (PEP 810) வந்தது: `lazy import pandas as pd` தொகுதியை முதல் பயன்பாடு வரை ஏற்றுவதைத் தள்ளிப்போடுகிறது, அதனால் கனமான சார்புகளைக் கொண்ட ஸ்கிரிப்ட் கணிசமாக வேகமாகத் தொடங்குகிறது.

## டெர்மினலில் Python கட்டளைகள்

«python கட்டளைகள்» என்ற தனிக் கேள்வி — இன்டர்ப்ரெட்டரை இயக்கவும் நூலகங்களை நிறுவவும் உள்ள கட்டளைகள். Windows-இல் `python3`-க்குப் பதிலாக பொதுவாக `python` அல்லது `py` எழுதப்படுகிறது.

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

| `python3 --version` | பதிப்பைக் காட்டுகிறது |

| `python3` | ஊடாடும் கன்சோல் REPL-ஐத் திறக்கிறது (வெளியேற — `exit()`) |

| `python3 script.py` | கோப்பை இயக்குகிறது |

| `python3 -c "print(2 + 2)"` | ஒரு வரியை இயக்குகிறது |

| `python3 -m venv .venv` | மெய்நிகர் சூழலை உருவாக்குகிறது |

| `source .venv/bin/activate` / `.venv\Scripts\activate` | சூழலை இயக்குகிறது (Linux, macOS / Windows) |

| `python3 -m pip install requests` | தொகுப்பை நிறுவுகிறது |

| `pip list`, `pip freeze > requirements.txt` | தொகுப்புகளின் பட்டியல் மற்றும் அதைச் சேமித்தல் |

| `pip install -r requirements.txt` | கோப்பிலிருந்து சார்புகளை நிறுவுகிறது |

| `python3 -m http.server 8000` | நடப்பு கோப்புறையில் எளிய வலை சர்வர் |

| `uv init`, `uv add requests`, `uv run main.py` | uv மேலாளர் மூலம் திட்டம், சார்பு மற்றும் இயக்கம் |

## தொடக்கநிலையாளர்களின் வழக்கமான தவறுகள்

- **நிபந்தனையில் `=` மூலம் ஒப்பிடுதல்** — நிபந்தனையில் `==` வேண்டும்; ஒற்றை `=` — ஒதுக்கல்.
- **`if`, `for`, `def`-க்குப் பின் மறந்த இரு புள்ளி** — `SyntaxError` தரும்.
- **சரத்தையும் எண்ணையும் கூட்டுதல்**: `"வயது: " + 25` — பிழை, `f"வயது: {25}"` எழுதுங்கள்.
- **சுழலின்போது பட்டியலை மாற்றுதல்** — நகலில் சுழலுங்கள் `for x in a[:]` அல்லது புதிய பட்டியலை உருவாக்குங்கள்.
- **`input()` சரத்தைத் தருகிறது** — கணிதத்துக்கு `int()` அல்லது `float()`-இல் சுற்றுங்கள்.

## முடிவு

Python தொடரமைப்பு உள்தள்ளல்கள், இரு புள்ளிகள் மற்றும் சிறிய கட்டமைப்புகளின் தொகுப்பின் மீது நிற்கிறது: நிபந்தனைகள், for மற்றும் while சுழல்கள், செயற்கூறுகள், வகுப்புகள். அவற்றுடன் இரண்டு டசன் உள்ளமைந்த செயற்கூறுகளையும் சரம், பட்டியல், அகராதி முறைகளையும் சேர்த்தால் அன்றாடப் பணிகளின் பெரும்பகுதியை நீங்கள் சமாளிக்கலாம். இந்த cheat sheet-ஐ சேமித்து வையுங்கள்; அட்டவணைகள் பழக்கமானதும் தொகுதிகள் மற்றும் ஒத்திசைவற்ற நிரலாக்கத்துக்குச் செல்லுங்கள் — அவை அனைத்தும் «Python 3.15: ஆரம்பநிலையிலிருந்து நிபுணர் வரை» பாடத்தில் படிப்படியாக நடைமுறையில் விளக்கப்பட்டுள்ளன.

## FAQ

**Python-இல் உள்தள்ளலுக்கு எத்தனை இடைவெளிகள் வைக்க வேண்டும்?**

PEP 8 தரநிலைப்படி — ஒரு நிலைக்கு 4 இடைவெளிகள். முக்கியமானது — முழுத் தொகுதியிலும் ஒரே மாதிரியாக இருக்க வேண்டும், tab-களுடன் கலக்கக் கூடாது.

**பட்டியலுக்கும் tuple-க்கும் என்ன வித்தியாசம்?**

பட்டியல் மாற்றக்கூடியது, அதில் சேர்க்கலாம் மற்றும் அதே இடத்தில் வரிசைப்படுத்தலாம்; tuple மாற்ற முடியாதது, அதனால் அகராதியின் விசையாகவும் நிலையான மதிப்புத் தொகுப்புகளுக்கும் பொருந்தும்.

**Python பொருளின் அனைத்து முறைகளையும் நேரடியாக எப்படிப் பார்ப்பது?**

பெயர்களின் பட்டியலுக்கு dir(obj), விளக்கத்துக்கு help(obj) அழையுங்கள் — எடுத்துக்காட்டாக help(str) சரத்தின் அனைத்து முறைகளையும் காட்டும்.

**sort() மற்றும் sorted() இடையே என்ன வித்தியாசம்?**

list.sort() பட்டியலையே வரிசைப்படுத்தி None தருகிறது; sorted() செயற்கூறு புதிய பட்டியலைத் தருகிறது, எந்த iterable தொகுப்புடனும் வேலை செய்கிறது.

**ஒவ்வொரு வரியின் இறுதியிலும் அரைப்புள்ளி தேவையா?**

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


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