Care sunt tipurile de date încorporate ale Python?

Question

Accepted Answer

Python are un set bogat de tipuri încorporate care acoperă numere, text, colecții și multe altele. A le cunoaște — și care sunt **mutable** vs **immutable** — este fundamental.

## Tipuri numerice

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

Nota: Python `int` are **precizie arbitrară** — nu se depășește niciodată (spre deosebire de inturi de dimensiune fixă în C/Java); `2 ** 1000` funcționează pur și simplu.

## Text și bytes

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

## Tipuri de colecție

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

## Tipul special None

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

## Verificarea tipurilor

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

## Rezumat: mutable vs immutable

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

Această distincție contează mult — obiectele immutable pot fi chei de dict și sunt sigure de împărțit; obiectele mutable se pot schimba în mod neașteptat dacă sunt aliased.

## De ce contează

Tipurile încorporate sunt vocabularul al tot codul Python.

A cunoaște scopul fiecăruia (list pentru secvențe ordonate, dict pentru perechi cheie-valoare, set pentru unicitate, tuple pentru înregistrări fixe), numerele întregi cu precizie arbitrară, și în special diviziunea **mutable-vs-immutable** (care guvernează cheile de dict, bug-urile de aliasing și ce poate fi împărțit în siguranță) este fundamental.

A alege tipul potrivit pentru sarcină — și a înțelege mutabilitatea sa — este o abilitate de bază în Python care afectează corectitudinea și performanța în întreg programul.