Typen in Python

Dit artikel legt de typen in Python uit.

YouTube Video

Typen in Python

De typing module in Python wordt gebruikt om type-aanwijzingen in Python in te voeren. Het werd oorspronkelijk geïntroduceerd in Python 3.5 en wordt gebruikt om de leesbaarheid en het onderhoud van de code te verbeteren. Type-aanwijzingen beïnvloeden de uitvoeringstijd van de code niet, maar stellen type-controle met IDE's en statische analysetools mogelijk.

Basisprincipes van Type-aanwijzingen

Type-aanwijzingen verduidelijken de intentie van de code door expliciet de typen van functies en variabelen te specificeren. In het onderstaande voorbeeld worden typen gespecificeerd voor de argumenten en de retourwaarde.

1def add_numbers(a: int, b: int) -> int:
2    return a + b
3
4result: int = add_numbers(5, 10)
5print(result)  # 15

In de bovenstaande code zijn a en b van het type integer (int), en de retourwaarde van de functie wordt ook expliciet vermeld als een integer. Zelfs met type-aanwijzingen worden typen niet strikt afgedwongen, maar waarschuwingen kunnen tijdens de ontwikkeling worden weergegeven als er type-conflicten zijn.

Belangrijke Type-aanwijzingen

De typing module in Python biedt verschillende klassen en functies om type-aanwijzingen te definiëren. Hieronder staat een lijst met veelvoorkomende type-aanwijzingen.

• int: geheel getal
• str: tekst of string
• float: kommagetal
• bool: booleaanse waarde
• List: lijst
• Dict: woordenboek
• Tuple: tuple
• Set: verzameling

List type

Het lijsttype wordt gespecificeerd met behulp van de List-klasse. U kunt ook expliciet het type elementen binnen een lijst specificeren.

1from typing import List
2
3def sum_list(numbers: List[int]) -> int:
4    return sum(numbers)
5
6print(sum_list([1, 2, 3]))  # 6

In dit voorbeeld wordt verwacht dat alle elementen van de lijst van het type int zijn.

Dict-type

Een woordenboektype wordt gedefinieerd met behulp van Dict. De typen van de sleutels en waarden kunnen worden gespecificeerd.

1from typing import Dict
2
3def get_student_age(students: Dict[str, int], name: str) -> int:
4    return students.get(name, 0)
5
6students = {"Alice": 23, "Bob": 19}
7print(get_student_age(students, "Alice"))  # 23

In dit voorbeeld gebruikt de woordenlijst str als het sleutentype en int als het waarde-type.

Tuple-type

Tuples worden gespecificeerd met behulp van het Tuple-type. U kunt het type van elk element in een tuple individueel specificeren.

1from typing import Tuple
2
3def get_person() -> Tuple[str, int]:
4    return "Alice", 30
5
6name, age = get_person()
7print(name, age)  # Alice 30

Hier laat de get_person-functie zien dat deze een tuple retourneert die een tekenreeks en een geheel getal bevat.

Union-type

Het Union-type wordt gebruikt om expliciet aan te geven dat meerdere typen acceptabel zijn.

1from typing import Union
2
3def process_value(value: Union[int, float]) -> float:
4    return value * 2.0
5
6print(process_value(10))  # 20.0
7print(process_value(3.5))  # 7.0

In dit voorbeeld accepteert de functie process_value een int of float als argument en retourneert een resultaat van het type float.

Optional-type

Het Optional-type wordt gebruikt wanneer een variabele None kan zijn. Het wordt aangeboden als een afkorting voor Union[Type, None].

1from typing import Optional
2
3def greet(name: Optional[str] = None) -> str:
4    if name is None:
5        return "Hello, Guest!"
6    return f"Hello, {name}!"
7
8print(greet())  # Hello, Guest!
9print(greet("Alice"))  # Hello, Alice!

Hier wordt aangegeven dat, als name niet wordt gespecificeerd, het wordt behandeld als None.

Generieke typen

Generieke typen zijn een manier om abstract weer te geven welk type elementen een datastructuur bevat. In de typing-module kunt u generieke typen definiëren met behulp van TypeVar.

1from typing import TypeVar, List
2
3T = TypeVar('T')
4
5def get_first_element(elements: List[T]) -> T:
6    return elements[0]
7
8print(get_first_element([1, 2, 3]))  # 1
9print(get_first_element(["a", "b", "c"]))  # a

In dit voorbeeld is get_first_element een functie die het eerste element van een lijst retourneert en deze werkt ongeacht het type van de lijst.

Type-aliasen

Een type-alias is een manier om complexe typedefinities te vereenvoudigen door ze een duidelijke naam te geven.

1from typing import List, Tuple
2
3Coordinates = List[Tuple[int, int]]
4
5def get_coordinates() -> Coordinates:
6    return [(0, 0), (1, 1), (2, 2)]
7
8print(get_coordinates())  # [(0, 0), (1, 1), (2, 2)]

In dit voorbeeld wordt een type-alias Coordinates gedefinieerd om eenvoudig een type met tuples in een lijst weer te geven.

Samenvatting

De typing-module in Python is zeer nuttig voor het verbeteren van de leesbaarheid en onderhoudbaarheid van code. Door type hints correct te gebruiken, kunt u typefouten en bugs helpen voorkomen, vooral in grootschalige projecten of teamontwikkeling. Types zijn slechts een hulpmiddel voor ontwikkeling en hebben geen invloed op het gedrag tijdens de uitvoering, waardoor de flexibiliteit van de code behouden blijft.

Je kunt het bovenstaande artikel volgen met Visual Studio Code op ons YouTube-kanaal. Bekijk ook het YouTube-kanaal.

YouTube Video