Python चे built-in data types कोणते आहेत?

Question

Accepted Answer

Python मध्ये संख्या, मजकूर, संग्रह आणि आणखी बरेच काही कव्हर करणारे समृद्ध प्रकारांचा संच आहे. त्यांना जाणून घेणे — आणि कोणते **mutable** विरुद्ध **immutable** आहेत हे जाणून घेणे — हे मूलभूत आहे.

## Numeric types

```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)
```

Note: Python `int` मध्ये **arbitrary precision** आहे — हे कधीही overflow होत नाही (C/Java मध्ये fixed-size ints च्या विपरीत); `2 ** 1000` फक्त काम करते.

## Text and bytes

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

## Collection types

```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
```

## The special None type

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

## Checking types

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

## Mutable vs immutable summary

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

हा फरक खूप महत्वाचा आहे — immutable objects हे dict keys असू शकतात आणि साधारण शेअर करण्यासाठी सुरक्षित आहेत; mutable ones अनपेक्षितपणे बदलू शकतात जर aliased असतील.

## हे का महत्वाचे आहे

Built-in types हे सर्व Python code ची शब्दावली आहेत.

प्रत्येकाचे उद्देश जाणून घेणे (ordered sequences साठी list, key-value साठी dict, uniqueness साठी set, fixed records साठी tuple), arbitrary-precision integers, आणि विशेषत: **mutable-vs-immutable** split (जे dict keys, aliasing bugs, आणि काय सुरक्षितपणे शेअर केले जाऊ शकते हे नियंत्रित करते) हे मूलभूत आहे.

काम साठी योग्य प्रकार निवडणे — आणि त्याचे mutability समजून घेणे — हा एक मूलभूत Python कौशल्य आहे जो संपूर्ण प्रोग्रामद्वारे शुद्धता आणि कार्यक्षमता प्रभावित करते.