Vilka är Pythons inbyggda datatyper?

Question

Accepted Answer

Python har en omfattande uppsättning inbyggda typer som täcker siffror, text, samlingar och mycket mer. Att känna till dem — och vilka som är **muterbara** respektive **omuterbara** — är grundläggande.

## Numeriska typer

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

Notering: Python `int` har **godtycklig precision** — den överflödar aldrig (till skillnad från fixed-size ints i C/Java); `2 ** 1000` fungerar bara.

## Text och bytes

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

## Samlingstyper

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

## Den speciella None-typen

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

## Kontroll av typer

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

## Sammanfattning muterbara kontra omuterbara

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

Den här skillnaden spelar stor roll — omuterbara objekt kan vara dict-nycklar och är säkra att dela; muterbara kan ändras oväntat om de är aliaserade.

## Varför det spelar roll

De inbyggda typerna är vokabulären för all Python-kod.

Att känna till varje typs syfte (list för ordnade sekvenser, dict för nyckel-värde, set för unikhet, tuple för fasta poster), godtycklig precision-heltal, och särskilt **muterbara-vs-omuterbara**-uppdelningen (som styr dict-nycklar, aliasing-buggar och vad som kan delas säkert) är grundläggande.

Att välja rätt typ för jobbet — och förstå dess mutabilitet — är en kärnkompetens i Python som påverkar korrekthet och prestanda under hela programmet.