# Welke gegevenstypen heeft Python?

Python-gegevenstypen zijn essentieel voor het weergeven, verwerken en gebruiken van gegevens. Door **verschillende gegevenstypen** te gebruiken, kunt u informatie op een efficiënte manier opslaan en de prestaties van uw toepassing optimaliseren.

## Wat zijn Python-gegevenstypen?

Python-datatypes zijn **waardecategorieën** die worden gebruikt om verschillende soorten gegevens weer te geven. Ze bepalen hoe informatie kan worden opgeslagen en gemanipuleerd. Python biedt een reeks verschillende datatypes, waaronder integers (gehele getallen), floats (decimale getallen) en strings (tekenreeksen). Meer geavanceerde types zijn onder andere lijsten, tuples, woordenboeken en sets. Datatypes vergemakkelijken het structureren en verwerken van gegevens, waardoor ze cruciaal zijn voor het programmeren in Python.

Het primaire doel van Python-datatypes is om gegevens te structureren volgens vooraf gedefinieerde regels, zodat aan de behoeften van diverse toepassingen kan worden voldaan. Elk datatype heeft **verschillende functies en eigenschappen**. Lijsten houden bijvoorbeeld items in een geordende volgorde bij, terwijl woordenboeken sleutel-waardeparen gebruiken voor het gericht ophalen van gegevens. Door geschikte datatypes voor uw gegevens te selecteren, wordt uw programma flexibel en gemakkelijker te onderhouden.

## Welke soorten gegevenstypen zijn er in Python?

Python heeft verschillende ingebouwde gegevenstypen, waaronder:

- **Numerieke gegevenstypen**: `int`, `float`, `complex`
- **Tekenreeksen**: `str`
- **Sequentiële gegevenstypen**: `list`, `tuple`, `range`
- **Binaire typen**: `bytes`, `bytearray`, `memoryview`
- **Woordenboeken**: `dict`.
- **Booleaanse gegevenstypen**: `bool`.
- **Verzamelingen**: `set`, `frozenset`

### Numerieke gegevenstypen

Er zijn verschillende Python-gegevenstypen die u kunt gebruiken om met getallen te werken:

1. Integer (`int`): Het integer-type vertegenwoordigt hele getallen zonder decimalen.
2. Long (`long`): Long wordt gebruikt voor gehele getallen met een onbeperkte lengte. Vanaf Python 3 zijn `long` en `int` samengevoegd.
3. Float (`float`): Het float-type omvat getallen met decimalen.
4. Complex (`complex`): Het type complex omvat complexe getallen met een reëel deel en een imaginair deel, aangegeven door het achtervoegsel `j`.

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

### Touwtjes

Een Python-string (`str`) vertegenwoordigt een reeks tekens. Je kunt ze markeren met **enkele, dubbele of driedubbele aanhalingstekens**.

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

In Python zijn strings **onveranderlijk**, wat betekent dat ze niet meer kunnen worden gewijzigd nadat ze zijn aangemaakt. Strings ondersteunen echter talrijke methoden en bewerkingen voor manipulatie, aaneenschakeling en analyse. U kunt de resultaten opslaan in variabelen om nieuwe strings te verkrijgen.

Voorbeelden van stringbewerkingen:

- Lengte van een snaar: `len(str)`
- Opdelen: `str[start:end]`
- Strings samenvoegen: `str1 + str2`

### Sequentiële gegevenstypen

Sequentiële gegevenstypen in Python zijn gegevensstructuren die een **geordende verzameling** elementen opslaan. Ze bieden toegang tot elementen op basis van hun positie binnen de reeks. Er zijn verschillende sequentiële gegevenstypen in Python:

**Lijsten (`list`)**: Python-lijsten zijn **wijzigbare sequentiële gegevenstypen** die een geordende verzameling elementen vertegenwoordigen. U kunt elementen in een lijst wijzigen, toevoegen en verwijderen. Lijsten worden gemaakt met behulp van vierkante haken en bevatten elementen van verschillende gegevenstypen.

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

**Tuple (`tuple`)**: Tuples zijn **onveranderlijke sequentiële gegevenstypen** die, net als lijsten, een geordende verzameling elementen weergeven. In tegenstelling tot lijsten kunnen tuples achteraf niet worden gewijzigd. Gebruik ronde haakjes voor tuples.

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

**Range (`range`)**: Dit is een speciaal Python-gegevenstype dat wordt gebruikt voor het genereren van reeksen getallen, vaak gebruikt in lussen en iteraties. Het gegevenstype `range` creëert een reeks gehele getallen binnen een opgegeven bereik. Het **range-object** genereert getallen op verzoek in plaats van ze als een volledige lijst in het geheugen op te slaan, wat de efficiëntie verhoogt, met name bij grote getallenreeksen.

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

### Binaire typen

**Bytes (`bytes`)**: Het gegevenstype `bytes` vertegenwoordigt een **onveranderlijke reeks bytes**. Bytes kunnen worden aangemaakt met behulp van de `bytes()` constructor of het voorvoegsel `b`.

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

**bytearray (`bytearray`)**: In tegenstelling tot `bytes` behoort `bytearray` tot de **wijzigbare Python-gegevenstypen** en vertegenwoordigt het een reeks bytes. Dit betekent dat u de waarden na declaratie kunt wijzigen.

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

### Woordenboeken

In Python is een woordenboek (`dict`) een gegevensstructuur die een ongeordende verzameling elementen opslaat in de vorm van **sleutel-waardeparen**. In tegenstelling tot lijsten of tuples, die een geordende reeks elementen bevatten, worden unieke sleutels gebruikt om toegang te krijgen tot elementen in een woordenboek.

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

### Booleaanse gegevenstypen

Booleaanse Python-gegevenstypen vertegenwoordigen **waarheidswaarden** die waar (`True`) of onwaar (`False`) kunnen zijn. Deze gegevens zijn cruciaal voor logische evaluaties en beslissingen binnen een programma.

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

### Sets

Een set is een **ongeordende verzameling** unieke waarden waarin geen duplicaten zijn toegestaan. Je kunt deze gebruiken om meerdere elementen op te slaan, waarbij elk element uniek is.

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

Een `frozenset` is een **onveranderlijke versie van een set**. Eenmaal aangemaakt, kunnen er geen elementen meer worden toegevoegd, verwijderd of gewijzigd.

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


This is a markdown version of: [https://www.ionos.com/nl-be/digitalguide/websites/webontwikkeling/python-gegevenstypen/](https://www.ionos.com/nl-be/digitalguide/websites/webontwikkeling/python-gegevenstypen/) for AI/LLM consumption.