Typer i Python

Den här artikeln förklarar typer i Python.

YouTube Video

Typer i Python

typing-modulen i Python används för att introducera typanvisningar i Python. Den introducerades ursprungligen i Python 3.5 och används för att förbättra kodens läsbarhet och underhållbarhet. Typanvisningar påverkar inte kodens exekveringstid men möjliggör typkontroll med IDE:er och verktyg för statisk analys.

Grunderna i typanvisningar

Typanvisningar klargör kodens avsikt genom att uttryckligen specificera typerna för funktioner och variabler. I exemplet nedan specificeras typer för argumenten och returvärdet.

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

I koden ovan är a och b av typen heltal (int), och funktionens returvärde anges också uttryckligen som ett heltal. Även med typanvisningar tillämpas inte typer strikt, men varningar kan visas under utveckling om det finns typkonflikter.

Viktiga typanvisningar

typing-modulen i Python tillhandahåller olika klasser och funktioner för att definiera typanvisningar. Nedan finns en lista över vanliga typanvisningar.

• int: heltal
• str: sträng
• float: flyttal
• bool: boolesk
• List: lista
• Dict: ordbok
• Tuple: tuppel
• Set: mängd

List-typen

Listtypen specificeras med hjälp av klassen List. Du kan också uttryckligen ange typen av element i en lista.

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

I det här exemplet förväntas alla element i listan vara av typen int.

Dict-Typ

En ordbokstyp definieras med hjälp av Dict. Typerna för nycklar och värden kan specificeras.

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

I det här exemplet använder ordboken str som nyckeltyp och int som värdetyp.

Tuple-Typ

Tupler specificeras med hjälp av typen Tuple. Du kan ange typen för varje element i en tuppel individuellt.

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

Här visas get_person-funktionen som returnerar en tuppel som innehåller en sträng och ett heltal.

Union-Typ

Typen Union används för att uttryckligen indikera att flera typer är acceptabla.

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

I det här exemplet tar funktionen process_value antingen en int eller float som ett argument och returnerar ett resultat av typen float.

Optional-Typ

Typen Optional används när en variabel kan vara None. Det används som en förkortning för 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!

Här visas att när name inte är specificerat behandlas det som None.

Generiska Typer

Generiska typer är ett sätt att abstrakt representera vilken typ av element en datastruktur innehåller. I typing-modulen kan du definiera generiska typer med hjälp av 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

I det här exemplet är get_first_element en funktion som returnerar det första elementet i en lista, och den fungerar oavsett listans typ.

Typalias

Ett typalias är ett sätt att förenkla komplexa typdefinitioner genom att ge dem ett tydligt namn.

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

I det här exemplet definieras ett typalias Coordinates för att enkelt representera en typ med tupler inuti en lista.

Sammanfattning

typing-modulen i Python är mycket användbar för att förbättra läsbarheten och underhållbarheten i koden. Genom att korrekt använda typmarkeringar kan du hjälpa till att förebygga typkonflikter och buggar, särskilt i storskaliga projekt eller vid teamutveckling. Typer är enbart ett stödverktyg för utveckling och påverkar inte beteendet under körning, vilket bevarar kodens flexibilitet.

Du kan följa med i artikeln ovan med hjälp av Visual Studio Code på vår YouTube-kanal. Vänligen kolla även in YouTube-kanalen.

YouTube Video