Python యొక్క అంతర్నిర్మిత డేటా రకాలు ఏమిటి?

Question

Accepted Answer

Python సంఖ్యలు, టెక్స్ట్, సంग్రహాలు మరియు మరిన్ని విషయాలను కవర్ చేసే అంతర్నిర్మిత రకాల యొక్క సమృద్ధ సమితిని కలిగి ఉంది. వాటిని తెలుసుకోవడం — మరియు ఏ **మార్పుచేయగల** వర్సెస్ **మార్చ లేనిది** — ప్రాథమికమైనది.

## సంఖ్యాత్మక రకాలు

```python
x = 42          # int  — arbitrary precision (no overflow!)
y = 3.14        # float
z = 2 + 3j      # complex
b = True        # bool (a subclass of int: True == 1)
```

గమనించండి: Python `int` **ఏకపక్ష ఖచ్చితత్వం** కలిగి ఉంది — ఇది ఎప్పుడూ ఓవర్‌ఫ్లో చేయదు (C/Java లో స్థిర-పరిమాణ ints కాకుండా); `2 ** 1000` కేవలం పనిచేస్తుంది.

## టెక్స్ట్ మరియు bytes

```python
s = "hello"     # str  — Unicode text (immutable)
data = b"bytes" # bytes — raw binary (immutable)
```

## సంగ్రహ రకాలు

```python
lst = [1, 2, 3]            # list  — ordered, MUTABLE, allows duplicates
tup = (1, 2, 3)            # tuple — ordered, IMMUTABLE
d = {"a": 1, "b": 2}       # dict  — key→value, mutable, insertion-ordered
s = {1, 2, 3}              # set   — unordered, unique elements, mutable
fs = frozenset({1, 2})     # frozenset — immutable set
```

## ప్రత్యేక None రకం

```python
result = None   # NoneType — represents "no value" (like null)
if result is None:   # always compare to None with `is`, not ==
    ...
```

## రకాలను తనిఖీ చేయడం

```python
type(x)             # <class 'int'>
isinstance(x, int)  # True — the preferred check (handles subclasses)
```

## మార్పుచేయగల వర్సెస్ మార్చ లేనిది సారాంశం

```text
Immutable: int, float, bool, str, tuple, frozenset, bytes, None
Mutable:   list, dict, set, bytearray
```

ఈ వ్యత్యాసం చాలా పట్టుకుంటుంది — మార్చ లేనిది వస్తువులు dict కీలుగా ఉండవచ్చు మరియు భాగస్వామ్యం చేయడానికి సురక్షితమైనవి; మార్పుచేయగల వాటి alias చేయబడితే unexpectedly మార్పు చేయవచ్చు.

## ఎందుకు ఇది ముఖ్యమైనది

అంతర్నిర్మిత రకాలు సమస్త Python కోడ్ యొక్క పదజాలం.

ప్రతిটి రకం యొక్క ప్రయోజనాన్ని తెలుసుకోవడం (విధానబద్ధ సిద్ధాంతాల కోసం list, కీ-విలువ కోసం dict, విశిష్టత కోసం set, స్థిర రికార్డుల కోసం tuple), arbitrary-precision పూర్ణాంకాలు, మరియు ముఖ్యంగా **మార్పుచేయగల-వర్సెస్-మార్చ లేనిది** విభజన (dict కీలను, aliasing bugs, మరియు ఏమి సురక్షితంగా భాగస్వామ్యం చేయవచ్చు అని నిర్దేశిస్తుంది) ప్రాథమికమైనది.

కাজం కోసం సరైన రకాన్ని ఎంచుకోవడం — మరియు దాని mutability ని అర్థం చేసుకోవడం — Python యొక్క ప్రధాన నైపుణ్యం, ఇది ప్రోగ్రామ్ అంతటా ఖచ్చితత్వం మరియు పనితీరును ప్రభావితం చేస్తుంది.