Python ਦੇ built-in data types ਕਿਹੜੇ ਹਨ?

Question

Accepted Answer

Python ਵਿੱਚ ਸੰਖਿਆਵਾਂ, ਟੈਕਸਟ, ਸੰਗ੍ਰਹਾਂ ਅਤੇ ਹੋਰ ਬਹੁਤ ਸਾਰੇ ਪ੍ਰਕਾਰਾਂ ਦਾ ਇੱਕ ਅਮੀਰ ਸਮੂਹ ਹੈ। ਉਨ੍ਹਾਂ ਨੂੰ ਜਾਣਨਾ — ਅਤੇ ਕਿਹੜੇ **mutable** ਬਨਾਮ **immutable** ਹਨ — ਬੁਨਿਆਦੀ ਹੈ।

## ਸੰਖਿਆਤਮਕ ਕਿਸਮਾਂ

```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` ਕੋਲ **ਮਨਮਾਨੀ ਸ਼ੁੱਧਤਾ** ਹੈ — ਇਹ ਕਦੀ overflow ਨਹੀਂ ਹੁੰਦਾ (C/Java ਵਿੱਚ fixed-size 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)
```

## Mutable ਬਨਾਮ immutable ਸਾਰਾਂਸ਼

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

ਇਹ ਫਰਕ ਬਹੁਤ ਮਾਇਨੇ ਰੱਖਦਾ ਹੈ — immutable ਆਬਜੈਕਟ dict ਕਲੀਦਾਂ ਹੋ ਸਕਦੇ ਹਨ ਅਤੇ ਸਾਂਝਾ ਕਰਨ ਲਈ ਸੁਰੱਖਿਅਤ ਹਨ; mutable ਆਬਜੈਕਟ alias ਹੋਣ ਵੇਲੇ ਅਚਾਨਕ ਬਦਲ ਸਕਦੇ ਹਨ।

## ਇਹ ਕਿਉਂ ਮਾਇਨੇ ਰੱਖਦਾ ਹੈ

Built-in ਕਿਸਮਾਂ ਸਾਰੇ Python ਕੋਡ ਦੀ ਸ਼ਬਦਾਵਲੀ ਹਨ।

ਹਰ ਇੱਕ ਦਾ ਉਦੇਸ਼ ਜਾਣਨਾ (ordered sequences ਲਈ list, key-value ਲਈ dict, uniqueness ਲਈ set, fixed records ਲਈ tuple), ਮਨਮਾਨੀ-ਸ਼ੁੱਧਤਾ ਵਾਲੀਆਂ ਪੂਰਨ ਸੰਖਿਆਵਾਂ, ਅਤੇ ਖਾਸ ਤੌਰ 'ਤੇ **mutable-vs-immutable** ਵੰਡ (ਜੋ dict ਕਲੀਦਾਂ, aliasing ਬਗਾਂ, ਅਤੇ ਕੀ ਸੁਰੱਖਿਅਤ ਢੰਗ ਨਾਲ ਸਾਂਝਾ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ ਦਾ ਨਿਯਮ ਕਰਦੀ ਹੈ) ਬੁਨਿਆਦੀ ਹੈ।

ਕাਮ ਲਈ ਸਹੀ ਪ੍ਰਕਾਰ ਚੁਣਨਾ — ਅਤੇ ਇਸ ਦੀ mutability ਨੂੰ ਸਮਝਨਾ — ਇੱਕ ਮੂਲ Python ਹੁਨਰ ਹੈ ਜੋ ਪੂਰੀ ਪ੍ਰੋਗ੍ਰਾਮ ਵਿੱਚ ਸ਼ੁੱਧਤਾ ਅਤੇ ਪ੍ਰਦਰਸ਼ਨ ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਕਰਦਾ ਹੈ।