# Hvilke datatyper har Python?

Python-datatyper er afgørende for at kunne repræsentere, behandle og bruge data. Ved at anvende **forskellige datatyper** kan du gemme information på en effektiv måde og optimere din applikations ydeevne.

## Hvad er Python-datatyper?

Python-datatyper er **værdikategorier**, der bruges til at repræsentere forskellige typer data. De dikterer, hvordan information kan lagres og manipuleres. Python tilbyder en række forskellige datatyper, herunder heltal (hele tal), flydende tal (decimaltal) og strenge (tegnstrenge). Mere avancerede typer omfatter lister, tupler, ordbøger og sæt. Datatyper letter datastrukturering og -behandling, hvilket gør dem afgørende for Python-programmering.

Det primære formål med Python-datatyper er at strukturere data i henhold til foruddefinerede regler, så forskellige applikationers behov kan opfyldes. Hver datatype har **forskellige funktioner og egenskaber**. For eksempel opbevarer lister elementer i en bestemt rækkefølge, mens ordbøger bruger nøgle-værdipar til målrettet datahentning. Ved at vælge passende datatyper til dine data bliver dit program fleksibelt og lettere at vedligeholde.

## Hvilke datatyper findes der i Python?

Python har forskellige indbyggede datatyper, herunder:

- **Numeriske datatyper**: `int`, `float`, `complex`
- **Strings**: `str`
- **Sekventielle datatyper**: `list`, `tuple`, `range`
- **Binære typer**: `bytes`, `bytearray`, `memoryview`
- **Ordbøger**: `dict`.
- **Boolske datatyper**: `bool`.
- **Mængder**: `set`, `frozenset`

### Numeriske datatyper

Der er flere Python-datatyper, som du kan bruge til at arbejde med tal:

1. Heltal (`int`): Heltaltypen repræsenterer hele tal uden decimaler.
2. Long (`long`): Long bruges til heltal med ubegrænset længde. Fra Python 3 er `long` og `int` slået sammen.
3. Float (`float`): Float-typen omfatter tal med decimaler.
4. Complex (`complex`): Complex-typen omfatter komplekse tal med en reel del og en imaginær del, angivet med suffikset `j`.

```python
# Variable with integer value. 
a=3 
 
# Variable with float value. 
b=3.17 
 
# Variable with complex value. 
c=50+7j
```

### Strengene

En Python-streng (`str`) repræsenterer en sekvens af tegn. Du kan markere dem med **enkelt, dobbelt eller tredobbelt anførselstegn**.

```python
# Single quotes 
str1 = 'Hello World!' 
 
# Double quotes 
str2 = "This is a string." 
 
# Triple quotes for multiline strings 
str3 = '''This is a multiline string.'''
```

I Python er strenge **uforanderlige**, hvilket betyder, at de ikke kan ændres, når de først er oprettet. Strenge understøtter dog adskillige metoder og operationer til manipulation, sammenkædning og analyse. Du kan gemme resultaterne i variabler for at få nye strenge.

Eksempler på strengoperationer:

- Strengens længde: `len(str)`
- Opdeling: `str[start:end]`
- Sammenkædning af strenge: `str1 + str2`

### Sekventielle datatyper

Sekventielle datatyper i Python er datastrukturer, der gemmer en **ordnet samling** af elementer. De giver adgang til elementer baseret på deres position i sekvensen. Der findes flere sekventielle Python-datatyper:

**Lister (`list`)**: Python-lister er **modificerbare sekventielle datatyper**, der repræsenterer en ordnet samling af elementer. Du kan ændre, tilføje og fjerne elementer i en liste. Lister oprettes ved hjælp af firkantede parenteser og indeholder elementer af forskellige datatyper.

```python
my_list = [1, 2, 3, 'Hello', 'World']
```

**Tuple (`tuple`)**: Tuples er **uforanderlige sekventielle datatyper**, der ligesom lister viser en ordnet samling af elementer. I modsætning til lister kan tuples ikke ændres efterfølgende. Brug runde parenteser til tuples.

```python
my_tuple = (4, 5, 6, 'Python')
```

**Range (`range`)**: Dette er en speciel Python-datatype, der bruges til at generere talsekvenser, som ofte anvendes i sløjfer og iterationer. Datatypen `range` opretter en sekvens af heltal inden for et specificeret interval. **Range-objektet** genererer tal efter behov i stedet for at gemme dem som en komplet liste i hukommelsen, hvilket øger effektiviteten, især ved store talsekvenser.

```python
# Range from 0 to 4 
my_range = range(4) 
for i in my_range: 
    print(i) 
# Output: 0, 1, 2, 3
```

### Binære typer

**Bytes (`bytes`)**: Datatypen `bytes` repræsenterer en **uforanderlig sekvens af bytes**. Bytes kan oprettes ved hjælp af konstruktøren `bytes()` eller præfikset `b`.

```python
my_bytes = b'Hello'
```

**bytearray (`bytearray`)**: I modsætning til `bytes` hører `bytearray` til de **modificerbare Python-datatyper** og repræsenterer en sekvens af bytes. Det betyder, at du kan ændre værdierne efter deklarationen.

```python
my_bytearray = bytearray(b'Python')
```

### Ordbøger

I Python er en ordbog (`dict`) en datastruktur, der gemmer en uordnet samling af elementer i form af **nøgle-værdipar**. I modsætning til lister eller tupler, der indeholder en ordnet rækkefølge af elementer, bruges unikke nøgler til at få adgang til elementer i en ordbog.

```python
my_dict = {
    "name": "Max",
    "age": 25,
    "city": "Berlin"
}
```

### Boolske datatyper

Boolske Python-datatyper repræsenterer **sandhedsværdier**, der kan være enten sande (`True`) eller falske (`False`). Disse data er afgørende for logiske evalueringer og beslutninger inden for et program.

```python
a = True
b = False
result_1 = (a and b) # returns False
result_2 = (a or b) # returns True
result_3 = (not a) # returns False
```

### Sæt

Et sæt er en **uordnet samling** af unikke værdier, der ikke tillader dubletter. Du kan bruge det til at gemme flere elementer, hvor hvert element er unikt.

```python
my_set = {1, 2, 3, 4, 5}
```

En `frozenset` er en **uforanderlig version af et sæt**. Når det først er oprettet, kan elementer ikke tilføjes, fjernes eller ændres.

```python
my_set = {1, 2, 3, 4, 5}
frozen_set = frozenset(my_set)
```


This is a markdown version of: [https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/python-datatyper/](https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/python-datatyper/) for AI/LLM consumption.