We can annotate variable-length homogeneous tuples using the … literal (aka Ellipsis) like this: def process_tuple(t: Tuple[str, …]): … or for Python3.9+ def process_tuple(t: tuple[str, …]): … After that, the errors should go away. From the docs: To specify a variable-length tuple of homogeneous type, use literal ellipsis, e.g. Tuple[int, …]. A plain Tuple is … Read more
The prefered Syntax for a typed named tuple since 3.6 is from typing import NamedTuple class Point(NamedTuple): x: int y: int = 1 # Set default value Point(3) # -> Point(x=3, y=1) Edit Starting Python 3.7, consider using dataclasses (your IDE may not yet support them for static type checking): from dataclasses import dataclass @dataclass … Read more
Type hinting the Color class should work: def get_color_return_something(some_color: Color): print(some_color.value)
See the fifth paragraph of the abstract in the PEP you link to: While these annotations are available at runtime through the usual __annotations__ attribute, no type checking happens at runtime . Instead, the proposal assumes the existence of a separate off-line type checker which users can run over their source code voluntarily
You have a forward declaration; functions (to be bound as methods) are created before the class is, so the name Vector doesn’t yet exist. Only when all of the class body has been executed, can Python create the class object and bind the name Vector to it. Simply use a string with the name instead: … Read more
Use float only, as int is implied in that type: def my_func(number: float): PEP 484 Type Hints specifically states that: Rather than requiring that users write import numbers and then use numbers.Float etc., this PEP proposes a straightforward shortcut that is almost as effective: when an argument is annotated as having type float, an argument … Read more
According to PEP 526, this is not allowed: In addition, one cannot annotate variables used in a for or with statement; they can be annotated ahead of time, in a similar manner to tuple unpacking Annotate it before the loop: i: int for i in range(5): pass PyCharm 2018.1 and up now recognizes the type … Read more
Until Python 3.9 added support for type hinting using standard collections, you had to use typing.Tuple and typing.List if you wanted to document what type the contents of the containers needed to be: def f(points: Tuple[float, float]): return map(do_stuff, points) Up until Python 3.8, tuple and list did not support being used as generic types. … Read more
You are always returning one object; using return one, two simply returns a tuple. So yes, -> Tuple[bool, str] is entirely correct. Only the Tuple type lets you specify a fixed number of elements, each with a distinct type. You really should be returning a tuple, always, if your function produces a fixed number of … Read more
The former is correct, if arg accepts an instance of CustomClass: def FuncA(arg: CustomClass): # ^ instance of CustomClass In case you want the class CustomClass itself (or a subtype), then you should write: from typing import Type # you have to import Type def FuncA(arg: Type[CustomClass]): # ^ CustomClass (class object) itself Like it … Read more