Section 1.1: TypeVar — Defining Type Variables

As indicated by its name, TypeVar is a construct for defining a type variable that lacks a specific type. Although it may seem unnecessary at first glance, its utility becomes apparent through examples:

from typing import TypeVar, List

T = TypeVar('T')

def get_first(l: List[T]) -> T:

return l[0]

numbers: List[int] = [1, 2, 3]

result: int = get_first(numbers)

In the above snippet, we encounter a type mismatch issue. While Python will run the code, inconsistent types can lead to unforeseen bugs. The primary aim of type hints is to mitigate such risks.

To illustrate this, we can use Mypy, a popular type-checking tool:

pip install mypy

mypy test.py

This will yield an error indicating that the returned type must align with the items in the list l. The type variable ensures that the function returns the same type as the input list, enhancing type consistency across the codebase.

Section 1.2: NewType — Creating Distinct Types

At times, you may have variables with identical types that you wish to differentiate. The NewType feature serves this purpose well:

from typing import NewType

UserId = NewType('UserId', int)

OrderId = NewType('OrderId', int)

def get_user_name(user_id: UserId) -> str:

return "Yang Zhou"

def get_order_details(order_id: OrderId) -> str:

return "iPhone 2000"

user_id = UserId(2077)

order_id = OrderId(9527)

print(get_user_name(user_id))

print(get_order_details(order_id))

Attempting to pass an integer directly to get_user_name will trigger a type-checking error, reinforcing the importance of type safety. While NewType is not universally embraced in the Python community, it serves a valuable role in making code more readable.

Section 2.1: Final — Simplifying Constant Declarations

Unlike many programming languages, Python lacks a formal mechanism for declaring constants. Historically, constants are simply represented by uppercase names. However, with Python 3.8, the Final type hint allows for cleaner constant declarations:

from typing import Final

DATABASE: Final = "MySQL"

This approach adds an extra layer of type safety, preventing alterations to constants defined as Final.

Section 2.2: TypedDict — Enhancing Dictionary Safety

To specify types for key-value pairs in dictionaries, you can define a class that inherits from TypedDict:

from typing import TypedDict

class Leader(TypedDict):

name: str

year: int

author: Leader = {"name": "Yang Zhou", "year": 2077}

The TypedDict allows for a more structured and type-safe dictionary, improving data integrity.

The second video, "5 Reasons Why You Should Use Type Hints In Python," discusses the practical benefits of incorporating type hints into your code.

Section 2.3: Protocol — Embracing Duck Typing

The concept of duck typing is prevalent in Python, and with the introduction of Protocol in Python 3.8, you can define what methods an object must have to be accepted by a function:

from typing import Protocol

class SuperHero(Protocol):

def fly(self) -> None:

pass

def call_a_hero(hero: SuperHero) -> None:

pass

This allows flexibility in your code, as any object fulfilling the protocol can be treated as a SuperHero.