【python3】显式变量类型 typing

在Python 3中使用typing模块可以带来几个好处：

1. 增强代码可读性和可维护性： 使用类型提示可以让代码更易于理解，特别是对于其他人阅读或维护你的代码时更有帮助。类型提示可以清晰地表达函数参数和返回值的预期类型。

2. 静态类型检查： 使用类型提示可以让静态类型检查工具如mypy等在代码中进行类型检查，帮助发现潜在的类型错误和逻辑问题，提前发现并解决bug。

3. 更好的自我文档化： 类型提示可以作为一种文档形式，帮助其他开发者理解你的代码中函数的用法和期望的参数类型。

4. 提高开发效率： 使用类型提示可以让IDE提供更好的自动补全和代码提示，提高开发效率，同时也可以减少运行时类型错误的发生，减少调试时间。

使用 typing

typing 模块是 Python 3.5 引入的一个标准库，用于支持类型提示。它提供了一组用于在函数声明、变量声明等位置指定类型的工具。

下面是一些 typing 模块的常见用法：

1. 指定函数参数和返回值的类型：

from typing import List, Tuple

def greet(name: str) -> str:
    return "Hello, " + name

def calculate_average(numbers: List[float]) -> float:
    return sum(numbers) / len(numbers)

def process_data(data: Tuple[str, int]) -> None:
    name, age = data
    print(f"Name: {name}, Age: {age}")

2. 指定变量的类型：

from typing import Dict

person: Dict[str, str] = {"name": "John", "age": "30"}

3. 使用泛型（Generics）：

from typing import TypeVar, List

T = TypeVar('T')

def first_item(items: List[T]) -> T:
    return items[0]

4. 支持更复杂的类型提示，如联合类型和可选类型：

from typing import Union, Optional

def process_input(input_data: Union[str, int]) -> Optional[int]:
    if isinstance(input_data, str):
        return None
    else:
        return input_data

联合类型

1. 联合类型（Union）：
   联合类型允许在类型提示中指定多个可能的类型之一。这在函数参数或变量的类型不确定时非常有用。

例如，假设有一个函数，接受字符串或整数作为参数，可以这样定义它的类型提示：

from typing import Union

def process_data(data: Union[str, int]) -> None:
    if isinstance(data, str):
        print(f"Processing string data: {data}")
    elif isinstance(data, int):
        print(f"Processing integer data: {data}")
    else:
        print("Unsupported data type")

在这个例子中，process_data 函数的参数 data 可以是 str 类型或 int 类型中的任何一个。使用 Union 类型可以使得类型提示更加灵活。

可选类型

2. 可选类型（Optional）：
   可选类型表示一个变量可以是某种类型的值，也可以是 None。通常用于表达函数的返回值可能是有意义的值，也可能是空值的情况。

例如，假设有一个函数，根据传入的年龄计算退休年龄，但如果传入的年龄为 None，则返回值也为 None，可以这样定义它的类型提示：

from typing import Optional

def calculate_retirement_age(age: Optional[int]) -> Optional[int]:
    if age is None:
        return None
    else:
        return 65 - age

在这个例子中，age 参数和返回值都使用了 Optional[int] 类型，表示它们可以是 int 类型的值，也可以是 None。这样的类型提示可以更清晰地表达函数的行为。

泛型

泛型（Generics）是一种编程语言特性，允许在编写代码时使用参数化类型。通过泛型，可以编写出灵活、通用的代码，而不必提前指定具体的数据类型。在 Python 中，泛型主要通过 typing 模块来实现。

以下是关于泛型的详细讲解：

1. 泛型类型参数（Type Parameters）：
   在泛型中，可以定义类型参数，它们代表着任意类型。在 Python 中，通常使用 TypeVar 来创建类型参数。例如：

   from typing import TypeVar, List
   
   T = TypeVar('T')  # 创建一个类型参数 T
   
   def first_item(items: List[T]) -> T:
       return items[0]
   

   在这个例子中，T 是一个类型参数，代表着列表中的元素的类型。函数 first_item 接受一个列表作为参数，并返回列表中的第一个元素。由于 T 是泛型类型参数，因此可以接受任何类型的列表作为参数。

2. 泛型函数和泛型类：
   泛型不仅可以应用于函数，还可以应用于类。例如，可以编写一个泛型的栈类，可以存储任意类型的元素：

   from typing import TypeVar, Generic, List
   
   T = TypeVar('T')
   
   class Stack(Generic[T]):
       def __init__(self):
           self._items: List[T] = []
   
       def push(self, item: T) -> None:
           self._items.append(item)
   
       def pop(self) -> T:
           return self._items.pop()
   
       def is_empty(self) -> bool:
           return len(self._items) == 0
   

   在这个例子中，Stack 类是一个泛型类，它使用了类型参数 T。这使得 Stack 类可以用于存储任意类型的元素。

3. 泛型约束（Generic Constraints）：
   可以对泛型类型参数进行约束，以限制其可能的类型。例如，可以使用 TypeVar 的 bound 参数来约束类型参数的类型：

   from typing import TypeVar, List, Union
   
   T = TypeVar('T', int, float)  # T 可以是 int 或 float 类型
   
   def process_data(data: List[T]) -> Union[int, float]:
       return sum(data)
   

   在这个例子中，T 的类型被约束为 int 或 float，这样在函数中就可以确保参数 data 中的元素类型是符合预期的。

泛型使得代码更加灵活和可重用，通过将类型作为参数传递，可以编写出更通用的函数和类，从而提高了代码的可维护性和可扩展性。