Suppose I have a function:

    def get_some_date(some_argument: int=None) -&gt; %datetime_or_None%:
        if some_argument is not None and some_argument == 1:
            return datetime.utcnow()
        else:
            return None

How do I specify the return type for something that can be `None`?

How to specify &quot;nullable&quot; return type with type hints

I&#39;m using Python 3 typing feature for better autocomplete.

Many times I have functions that return key/value (dictionary) with specific keys. super simple example:

    def get_info(name):
        name_first_letter = name[0]
        return {&#39;my_name&#39;: name, &#39;first_letter&#39;: name_first_letter}


I want to add type hinting to this function to tell others who use this function what to expect.

I can do something like:

     class NameInfo(object):
         def __init__(self, name, first_letter):
             self.name = name
             self.first_letter = first_letter

and then change the function signature to:

    def get_info(name) -&gt; NameInfo:

But it requires too much code for each dictionary.

What is the best practice in that case? 


Python 3 dictionary with known keys typing

I&#39;m giving the Python `typing` module a shot.

I know that it&#39;s valid to specify the length of a `List` like the following*:

    List[float, float, float]   # List of 3 floats &lt;-- NOTE: this is not valid Python

Is there any shorthand for longer lists? What if I want to set it to 10 floats?

    List[float * 10]   # This doesn&#39;t work.

Any idea if this is possible, this would be handy.

----------

*NOTE: It turns out that supplying multiple arguments to `Sequence[]` (and its subclasses) in this manner is currently NOT valid Python. Furthermore, it is currently not possible to specify a `Sequence` length using the `typing` module in this way.

Specify length of Sequence or List with Python typing module

I noticed Python 3.5 and Python 3.6 added a lot of features about static type checking, so I tried with the following code (in python 3.6, stable version).

    from typing import List
    
    a: List[str] = []
    a.append(&#39;a&#39;)
    a.append(1)
    print(a)

What surprised me was that, Python didn&#39;t give me an error or warning, although `1` was appended to a `list` which should only contain strings. `Pycharm` detected the type error and gave me a warning about it, but it was not obvious and it was not shown in the output console, I was afraid sometimes I might miss it. I would like the following effects:

1. If it&#39;s obvious that I used the wrong type just as shown above, throw out a warning or error.
2. If the compiler couldn&#39;t reliably check if the type I used was right or wrong, ignore it.

Is that possible? Maybe `mypy` could do it, but I&#39;d prefer to use Python-3.6-style type checking (like `a: List[str]`) instead of the comment-style (like `# type List[str]`) used in `mypy`. And I&#39;m curious if there&#39;s a switch in native python 3.6 to achieve the two points I said above.

How to use type hints in python 3.6?

How do I use type hints to annotate a function that returns an `Iterable` that always yields two values: a `bool` and a `str`?  The hint `Tuple[bool, str]` is close, except that it limits the return value type to a tuple, not a generator or other type of iterable.

I&#39;m mostly curious because I would like to annotate a function `foo()` that is used to return multiple values like this:

    always_a_bool, always_a_str = foo()

Usually functions like `foo()` do something like `return a, b` (which returns a tuple), but I would like the type hint to be flexible enough to replace the returned tuple with a generator or list or something else.

How to annotate types of multiple return values?

I&#39;m trying to split my huge class into two; well, basically into the &quot;main&quot; class and a mixin with additional functions, like so:

`main.py` file:

    import mymixin.py

    class Main(object, MyMixin):
        def func1(self, xxx):
            ...


`mymixin.py` file:

    class MyMixin(object):
        def func2(self: Main, xxx):  # &lt;--- note the type hint
            ...

Now, while this works just fine, the type hint in `MyMixin.func2` of course can&#39;t work. I can&#39;t import `main.py`, because I&#39;d get a cyclic import and without the hint, my editor (PyCharm) can&#39;t tell what `self` is.

I&#39;m using Python 3.4, but I&#39;m willing to move to 3.5 if a solution is available there.

Is there any way I can split my class into two files and keep all the &quot;connections&quot; so that my IDE still offers me auto-completion and all the other goodies that come from it knowing the types?

Python type hinting without cyclic imports

Using Python 3&#39;s function annotations, it is possible to specify the type of items contained within a homogeneous list (or other collection) for the purpose of type hinting in PyCharm and other IDEs?

A pseudo-python code example for a list of int:

    def my_func(l:list&lt;int&gt;):
        pass


I know it&#39;s possible using Docstring...

    def my_func(l):
        &quot;&quot;&quot;
        :type l: list[int]
        &quot;&quot;&quot;
        pass
... but I prefer the annotation style if it&#39;s possible.

Type hinting a collection of a specified type

I have the following code in Python 3:

    class Position:
    
        def __init__(self, x: int, y: int):
            self.x = x
            self.y = y
    
        def __add__(self, other: Position) -&gt; Position:
            return Position(self.x + other.x, self.y + other.y)


But my editor (PyCharm) says that the reference `Position` can not be resolved (in the `__add__` method). How should I specify that I expect the return type to be of type `Position`?

Edit: I think this is actually a PyCharm issue. It actually uses the information in its warnings, and code completion.

![](http://i.imgur.com/yjjCWw3.png)

But correct me if I&#39;m wrong, and need to use some other syntax.

How do I type hint a method with the type of the enclosing class?

I&#39;m trying to understand how to use the `Optional` type hint. From [PEP-484][1], I know I can use `Optional` for `def test(a: int = None)` either as `def test(a: Union[int, None])` or `def test(a: Optional[int])`. 

But how about following examples?

    def test(a : dict = None):
        #print(a) ==&gt; {&#39;a&#39;: 1234}
        #or
        #print(a) ==&gt; None
        
    def test(a : list = None):
        #print(a) ==&gt; [1,2,3,4, &#39;a&#39;, &#39;b&#39;]
        #or
        #print(a) ==&gt; None

If `Optional[type]` seems to mean the same thing as `Union[type, None]`, why should I use `Optional[]` at all?


  [1]: https://www.python.org/dev/peps/pep-0484/

How should I use the Optional type hint?

In python 3.x, it is common to use return type annotation of a function, such as:

    def foo() -&gt; str:
        return &quot;bar&quot;

What is the correct annotation for the &quot;void&quot; type?

I&#39;m considering 3 options:

 1. ``def foo() -&gt; None:``
      - not logical IMO, because ``None`` is not a type,
 2. ``def foo() -&gt; type(None):``
      - using the best syntax I know for obtaining ``NoneType``,
 3. ``def foo():``
      - omit explicit return type information.

Option 2. seems the most logical to me, but I&#39;ve already seen some instances of 1.

Python void return type annotation

I am practicing using type hints in Python 3.5. One of my colleague uses `typing.Dict`:

    import typing
    
    
    def change_bandwidths(new_bandwidths: typing.Dict,
                          user_id: int,
                          user_name: str) -&gt; bool:
        print(new_bandwidths, user_id, user_name)
        return False
    
    
    def my_change_bandwidths(new_bandwidths: dict,
                             user_id: int,
                             user_name: str) -&gt;bool:
        print(new_bandwidths, user_id, user_name)
        return True
    
    
    def main():
        my_id, my_name = 23, &quot;Tiras&quot;
        simple_dict = {&quot;Hello&quot;: &quot;Moon&quot;}
        change_bandwidths(simple_dict, my_id, my_name)
        new_dict = {&quot;new&quot;: &quot;energy source&quot;}
        my_change_bandwidths(new_dict, my_id, my_name)
    
    if __name__ == &quot;__main__&quot;:
        main()

Both of them work just fine, there doesn&#39;t appear to be a difference. 

I have read the [`typing` module documentation](https://docs.python.org/3/library/typing.html).

Between `typing.Dict` or `dict` which one should I use in the program?


Difference between defining typing.Dict and dict?

Consider following piece of code:


    from collections import namedtuple
    point = namedtuple(&quot;Point&quot;, (&quot;x:int&quot;, &quot;y:int&quot;))

The Code above is just a way to demonstrate as to what I am trying to achieve.
I would like to make `namedtuple` with type hints. 

Do you know any elegant way how to achieve result as intended?



Type hints in namedtuple

I want to annotate a type of a variable in a `for`-loop. I tried this but it didn&#39;t work:

```py
for i: int in range(5):
    pass
``` 

What I expect is working autocomplete in PyCharm 2016.3.2, but using
pre-annotation didn&#39;t work:

```py
i: int
for i in range(5):
    pass
```

P.S. Pre-annotation works for PyCharm &gt;= 2017.1.

How do I annotate types in a for-loop?

Couldn&#39;t seem to find a definitive answer. I want to do a type hint for a function and the type being some custom class that I have defined, called it `CustomClass()`.

And then let&#39;s say in some function, call it `FuncA(arg)`, I have one argument named `arg`. Would the correct way to type hint `FuncA` be:

```
def FuncA(arg: CustomClass):
```

Or would it be:

```
from typing import Type

def FuncA(Arg:Type[CustomClass]):
```

Type hints with user defined classes

When it comes to constructors, and assignments, and method calls, the PyCharm IDE is pretty good at analyzing my source code and figuring out what type each variable should be. I like it when it&#39;s right, because it gives me good code-completion and parameter info, and it gives me warnings if I try to access an attribute that doesn&#39;t exist.

But when it comes to parameters, it knows nothing. The code-completion dropdowns can&#39;t show anything, because they don&#39;t know what type the parameter will be. The code analysis can&#39;t look for warnings.

    class Person:
        def __init__(self, name, age):
            self.name = name
            self.age = age

    peasant = Person(&quot;Dennis&quot;, 37)
    # PyCharm knows that the &quot;peasant&quot; variable is of type Person
    peasant.dig_filth()   # shows warning -- Person doesn&#39;t have a dig_filth method

    class King:
        def repress(self, peasant):
            # PyCharm has no idea what type the &quot;peasant&quot; parameter should be
            peasant.knock_over()   # no warning even though knock_over doesn&#39;t exist

    King().repress(peasant)
    # Even if I call the method once with a Person instance, PyCharm doesn&#39;t
    # consider that to mean that the &quot;peasant&quot; parameter should always be a Person

This makes a certain amount of sense. Other call sites could pass anything for that parameter. But if my method expects a parameter to be of type, say, `pygame.Surface`, I&#39;d like to be able to indicate that to PyCharm somehow, so it can show me all of `Surface`&#39;s attributes in its code-completion dropdown, and highlight warnings if I call the wrong method, and so on.

Is there a way I can give PyCharm a  hint, and say &quot;psst, this parameter is supposed to be of type `X`&quot;? (Or perhaps, in the spirit of dynamic languages, &quot;this parameter is supposed to quack like an `X`&quot;? I&#39;d be fine with that.)

----

**EDIT:** CrazyCoder&#39;s answer, below, does the trick. For any newcomers like me who want the quick summary, here it is:

    class King:
        def repress(self, peasant):
            &quot;&quot;&quot;
            Exploit the workers by hanging on to outdated imperialist dogma which
            perpetuates the economic and social differences in our society.

            @type peasant: Person
            @param peasant: Person to repress.
            &quot;&quot;&quot;
            peasant.knock_over()   # Shows a warning. And there was much rejoicing.

The relevant part is the `@type peasant: Person` line of the docstring.

If you also go to File &gt; Settings &gt; Python Integrated Tools and set &quot;Docstring format&quot; to &quot;Epytext&quot;, then PyCharm&#39;s View &gt; Quick Documentation Lookup will pretty-print the parameter information instead of just printing all the @-lines as-is.

How can I tell PyCharm what type a parameter is expected to be?

What&#39;s the difference of using `List`, `Tuple`, etc. from `typing` module:

    from typing import Tuple

    def f(points: Tuple):
        return map(do_stuff, points)

As opposed to referring to Python&#39;s types directly:

    def f(points: tuple):
        return map(do_stuff, points)

And when should I use one over the other?

Using List/Tuple/etc. from typing vs directly referring type as list/tuple/etc

I want to allow type hinting using Python 3 to accept sub classes of a certain class. E.g.:

    class A:
        pass

    class B(A):
        pass

    class C(A):
        pass
    
    def process_any_subclass_type_of_A(cls: A):
        if cls == B:
            # do something
        elif cls == C:
            # do something else

Now when typing the following code:

    process_any_subclass_type_of_A(B)

I get an PyCharm IDE hint &#39;Expected type A, got Type[B] instead.&#39;

How can I change type hinting here to accept any subtypes of A?

According to [PEP 484][1] (&quot;Expressions whose type is a subtype of a specific argument type are also accepted for that argument.&quot;), I understand that my solution `(cls: A)` should work?


  [1]: https://www.python.org/dev/peps/pep-0484/#type-definition-syntax

Subclass in type hinting

Has anyone implemented type hinting for the specific [`numpy.ndarray`](http://docs.scipy.org/doc/numpy/reference/arrays.ndarray.html) class?

Right now, I&#39;m using [`typing.Any`](https://docs.python.org/3/library/typing.html#the-any-type), but it would be nice to have something more specific.

For instance if the NumPy people added a [type alias](https://docs.python.org/3/library/typing.html#type-aliases) for their [array_like](http://docs.scipy.org/doc/numpy/user/basics.creation.html#converting-python-array-like-objects-to-numpy-arrays) object class. Better yet, implement support at the [dtype](http://docs.scipy.org/doc/numpy/reference/arrays.dtypes.html) level, so that other objects would be supported, as well as [ufunc](http://docs.scipy.org/doc/numpy/reference/ufuncs.html).

Type hinting / annotation (PEP 484) for numpy.ndarray

Python 3.6 is about to be released. [PEP 494 -- Python 3.6 Release Schedule][1] mentions the end of December, so I went through [What&#39;s New in Python 3.6][2] to see they mention the *variable annotations*:


&gt; [PEP 484][3] introduced standard for type annotations of function parameters, a.k.a. type hints. This PEP adds syntax to Python for annotating the types of variables including class variables and instance variables:
&gt;
&gt;     primes: List[int] = []
&gt;
&gt;     captain: str  # Note: no initial value!
&gt;
&gt;     class Starship:
&gt;	       stats: Dict[str, int] = {}
&gt;
&gt; Just as for function annotations, the Python interpreter does not attach any particular meaning to variable annotations and only stores them in a special attribute `__annotations__` of a class or module. In contrast to variable declarations in statically typed languages, the goal of annotation syntax is to provide an easy way to specify structured type metadata for third party tools and libraries via the abstract syntax tree and the `__annotations__` attribute.


So from what I read they are part of the type hints coming from Python 3.5, described in [What are Type hints in Python 3.5][4].

I follow the `captain: str` and `class Starship` example, but not sure about the last one: How does `primes: List[int] = []` explain? Is it defining an empty list that will just allow integers?


  [1]: https://www.python.org/dev/peps/pep-0494/
  [2]: https://docs.python.org/3.6/whatsnew/3.6.html
  [3]: https://www.python.org/dev/peps/pep-0484
  [4]: https://stackoverflow.com/q/32557920/1983854

What are variable annotations?

If I have a function like this:

    def foo(name, opts={}):
      pass

And I want to add type hints to the parameters, how do I do it? The way I assumed gives me a syntax error:

    def foo(name: str, opts={}: dict) -&gt; str:
      pass

The following doesn&#39;t throw a syntax error but it doesn&#39;t seem like the intuitive way to handle this case:

    def foo(name: str, opts: dict={}) -&gt; str:
      pass

I can&#39;t find anything in the [`typing` documentation](https://docs.python.org/3/library/typing.html) or on a Google search. 

Edit: I didn&#39;t know how default arguments worked in Python, but for the sake of this question, I will keep the examples above. In general it&#39;s much better to do the following:

    def foo(name: str, opts: dict=None) -&gt; str:
      if not opts:
        opts={}
      pass

How do I add default parameters to functions when using type hinting?

I have a function in python that can either return a `bool` or a `list`. Is there a way to specify the return types using type hints?

For example, is this the correct way to do it?

    def foo(id) -&gt; list or bool:
        ...

How to specify multiple return types using type-hints

I have this piece of code:

    
    import enum
    
    
    class Color(enum.Enum):
        RED = &#39;1&#39;
        BLUE = &#39;2&#39;
        GREEN = &#39;3&#39;
    
    
    def get_color_return_something(some_color):
        pass
    
How do I properly add type annotations to the `some_color` variable in this function, if I suppose that I&#39;ll receive an enum attribute from the Color enum (for example: `Color.RED`)?

Type annotations for Enum attribute

mypy is really handy and catches a lot of bugs, but when I write &quot;scientific&quot; applications, I often end up doing:

    def my_func(number: Union[float, int]):
        # Do something

```number``` is either a float or int, depending on the user&#39;s input. Is there an official way to do that?

mypy, type hint: Union[float, int] -&gt; is there a Number type?

Is it possible to use type hinting when unpacking a tuple?  I want to do this, but it results in a `SyntaxError`:

    from typing import Tuple
    
    t: Tuple[int, int] = (1, 2)
    a: int, b: int = t
    #     ^ SyntaxError: invalid syntax

Type hints when unpacking a tuple?

I&#39;m really unsure why this isn&#39;t working. Here is the important part of the code (it&#39;s from a leetcode challenge).
The first line throws the NameError.

```python
def totalFruit(self, tree: List[int]) -&gt; int:
    pass
```

If I try importing `List` first I get an error `No module named &#39;List&#39;`. I&#39;m using Python 3.7.3 from Anaconda.

NameError: name &#39;List&#39; is not defined

I have a function that takes a tuple of different lengths as an argument:

```
from typing import Tuple


def process_tuple(t: Tuple[str]):
    # Do nasty tuple stuff

process_tuple((&quot;a&quot;,))
process_tuple((&quot;a&quot;, &quot;b&quot;))
process_tuple((&quot;a&quot;, &quot;b&quot;, &quot;c&quot;))

```

When I annotate function like mentioned above, I get these error messages

```
fool.py:9: error: Argument 1 to &quot;process_tuple&quot; has incompatible type &quot;Tuple[str, str]&quot;; expected &quot;Tuple[str]&quot;
fool.py:10: error: Argument 1 to &quot;process_tuple&quot; has incompatible type &quot;Tuple[str, str, str]&quot;; expected &quot;Tuple[str]&quot;
```

`process_tuple` really works with tuples and I use them as immutable lists of variable length. I haven&#39;t found any consensus on this topic on the internet, so I wonder how should I annotate this kind of input. 

How to annotate function that takes a tuple of variable length? (variadic tuple type annotation)

[`TypeVar`](https://docs.python.org/3/library/typing.html#typing.TypeVar) and [`NewType`](https://docs.python.org/3/library/typing.html#newtype) seem related but I&#39;m not sure when I&#39;m supposed to use each or what the difference is at runtime and statically.

What is the difference between TypeVar and NewType?

According to [PEP-484][1], we should be able to type hinting a generator function as follows:

```py
from typing import Generator

def generate() -&gt; Generator[int, None, None]:
    for i in range(10):
        yield i

for i in generate():
    print(i)
```

However, the list comprehension gives the following error in PyCharm.

&gt; Expected &#39;collections.Iterable&#39;, got &#39;Generator[int, None, None]&#39; instead less... (⌘F1)

Any idea why PyCharm is considering this as error?

---

A few clarification after reading some answers. I am using PyCharm Community Edition 2016.3.2 (the latest version) and have imported the `typing.Generator` (updated in the code). The above code runs just fine, but PyCharm considers this an error:

[![enter image description here][2]][2]

So, I&#39;m wondering if this is actually an error or an unsupported feature in PyCharm.

  [1]: https://www.python.org/dev/peps/pep-0484/#annotating-generator-functions-and-coroutines
  [2]: https://i.stack.imgur.com/PGSwC.png

How to type hint a generator in Python 3?

The following produces `NameError: name &#39;Client&#39; is not defined`. How can I solve it?

    class Server():
        def register_client(self, client: Client)
            pass
    
    
    class Client():
        def __init__(self, server: Server):
            server.register_client(self)



Type hints: solve circular dependency

I have a function that looks like this:

    def check_for_errors(result):
   		if &#39;success&#39; in result:
            return True

        if &#39;error&#39; in result:
            raise TypeError

        return False

In successful run of this function, I should get a `bool`, but if there is an error I should get a `TypeError`- which is OK because I deal with it in another function.

My function first line looks like this:

    def check_for_errors(result: str) -&gt; bool:

My question is: Should I mention the error in my type hinting?

Python type hinting with exceptions

What is the proper way to annotate a function argument that expects a class object instead of an instance of that class?

In the example below, `some_class` argument is expected to be a type instance (which is a class), but the problem here is that `type` is too broad:

    def construct(some_class: type, related_data:Dict[str, Any]) -&gt; Any:
        ...

In the case where `some_class` expects a specific set of types objects, using `type` does not help at all. The `typing` module might be in need of a Class generic that does this:

    def construct(some_class: Class[Union[Foo, Bar, Baz]], related_data:Dict[str, Any]) -&gt; Union[Foo, Bar, Baz]:
        ...

In the example above, `some_class` is the `Foo`, `Bar` or `Faz` class, not an instance of it. It should not matter their positions in the class tree because `some_class: Class[Foo]` should also be a valid case. Therefore,

    # classes are callable, so it is OK
    inst = some_class(**related_data)

or

    # instances does not have __name__
    clsname = some_class.__name__

or

    # an operation that only Foo, Bar and Baz can perform.
    some_class.a_common_classmethod()

should be OK to mypy, pytype, PyCharm, etc.

How can this be done with current implementation (Python 3.6 or earlier)?

How to annotate a type that&#39;s a class object (instead of a class instance)?

Is there any difference between using `typing.Any` as opposed to `object` in typing? For example:

    def get_item(L: list, i: int) -&gt; typing.Any:
        return L[i]

Compared to:

    def get_item(L: list, i: int) -&gt; object:
        return L[i]

typing.Any vs object?

Python 3.7 was released a while ago, and I wanted to test some of the fancy new `dataclass`+typing features. Getting hints to work right is easy enough, with both native types and those from the `typing` module:

    &gt;&gt;&gt; import dataclasses
    &gt;&gt;&gt; import typing as ty
    &gt;&gt;&gt; 
    ... @dataclasses.dataclass
    ... class Structure:
    ...     a_str: str
    ...     a_str_list: ty.List[str]
    ...
    &gt;&gt;&gt; my_struct = Structure(a_str=&#39;test&#39;, a_str_list=[&#39;t&#39;, &#39;e&#39;, &#39;s&#39;, &#39;t&#39;])
    &gt;&gt;&gt; my_struct.a_str_list[0].  # IDE suggests all the string methods :)

But one other thing that I wanted to try was forcing the type hints as conditions during runtime, i.e. it should not be possible for a `dataclass` with incorrect types to exist. It can be implemented nicely with [`__post_init__`](https://www.python.org/dev/peps/pep-0557/#post-init-processing):

    &gt;&gt;&gt; @dataclasses.dataclass
    ... class Structure:
    ...     a_str: str
    ...     a_str_list: ty.List[str]
    ...     
    ...     def validate(self):
    ...         ret = True
    ...         for field_name, field_def in self.__dataclass_fields__.items():
    ...             actual_type = type(getattr(self, field_name))
    ...             if actual_type != field_def.type:
    ...                 print(f&quot;\t{field_name}: &#39;{actual_type}&#39; instead of &#39;{field_def.type}&#39;&quot;)
    ...                 ret = False
    ...         return ret
    ...     
    ...     def __post_init__(self):
    ...         if not self.validate():
    ...             raise ValueError(&#39;Wrong types&#39;)

This kind of `validate` function works for native types and custom classes, but not those specified by the `typing` module:

    &gt;&gt;&gt; my_struct = Structure(a_str=&#39;test&#39;, a_str_list=[&#39;t&#39;, &#39;e&#39;, &#39;s&#39;, &#39;t&#39;])
    Traceback (most recent call last):
	  a_str_list: &#39;&lt;class &#39;list&#39;&gt;&#39; instead of &#39;typing.List[str]&#39;
      ValueError: Wrong types

Is there a better approach to validate an untyped list with a `typing`-typed one? Preferably one that doesn&#39;t include checking the types of all elements in any `list`, `dict`, `tuple`, or `set` that is a `dataclass`&#39; attribute.

---

Revisiting this question after a couple of years, I&#39;ve now moved to use [`pydantic`](https://pydantic-docs.helpmanual.io/) in cases where I want to validate classes that I&#39;d normally just define a dataclass for. I&#39;ll leave my mark with the currently accepted answer though, since it correctly answers the original question and has outstanding educational value. 

Validating detailed types in python dataclasses

I&#39;m trying out Python&#39;s type annotations with abstract base classes to write some interfaces. Is there a way to annotate the possible types of `*args` and `**kwargs`?

For example, how would one express that the sensible arguments to a function are either an `int` or two `int`s? `type(args)` gives `Tuple` so my guess was to annotate the type as `Union[Tuple[int, int], Tuple[int]]`, but this doesn&#39;t work.

    from typing import Union, Tuple
    
    def foo(*args: Union[Tuple[int, int], Tuple[int]]):
        try:
            i, j = args
            return i + j
        except ValueError:
            assert len(args) == 1
            i = args[0]
            return i

    # ok
    print(foo((1,)))
    print(foo((1, 2)))
    # mypy does not like this
    print(foo(1))
    print(foo(1, 2))

Error messages from mypy:

    t.py: note: In function &quot;foo&quot;:
    t.py:6: error: Unsupported operand types for + (&quot;tuple&quot; and &quot;Union[Tuple[int, int], Tuple[int]]&quot;)
    t.py: note: At top level:
    t.py:12: error: Argument 1 to &quot;foo&quot; has incompatible type &quot;int&quot;; expected &quot;Union[Tuple[int, int], Tuple[int]]&quot;
    t.py:14: error: Argument 1 to &quot;foo&quot; has incompatible type &quot;int&quot;; expected &quot;Union[Tuple[int, int], Tuple[int]]&quot;
    t.py:15: error: Argument 1 to &quot;foo&quot; has incompatible type &quot;int&quot;; expected &quot;Union[Tuple[int, int], Tuple[int]]&quot;
    t.py:15: error: Argument 2 to &quot;foo&quot; has incompatible type &quot;int&quot;; expected &quot;Union[Tuple[int, int], Tuple[int]]&quot;

It makes sense that mypy doesn&#39;t like this for the function call because it expects there to be a `tuple` in the call itself. The addition after unpacking also gives a typing error that I don&#39;t understand.

How does one annotate the sensible types for `*args` and `**kwargs`?

Type annotations for *args and **kwargs

How can I specify the type hint of a variable as a *function type*? (See also: [PEP 483][1].)

    import typing
    
    def my_function(func: typing.Function):
        func()


  [1]: https://www.python.org/dev/peps/pep-0483/#fundamental-building-blocks

How can I specify the function type in my type hints?

I&#39;m currently working on creating a python linear algebra module for fun and for practice with the language. I recently tried to add type annotations to the module, as such:

    class Vector:
         # Various irrelevant implementation details
         def __add__(self, other: Vector) -&gt; Vector:
            # More implementation details....

However, when I try to import this, it spits out a `NameError: Name &#39;Vector&#39; is not defined`. I acknowledge that this question has already been answered, in a form, [here][1], but it doesn&#39;t seem to wholly provide an answer for my situation.

What I&#39;d like to know:

 * I&#39;ve defined the class literally in this file. Why does it say the name isn&#39;t defined?
 * How do I define `Vector` in such a way that it can be used for annotations (as a `type`)?

  [1]: https://stackoverflow.com/questions/27461035/function-annotation-in-python-3-get-name-not-defined-error

Name not defined in type annotation

One of the most talked-about features in Python 3.5 is **type hints**.

An example of **type hints** is mentioned in [this article][1] and [this one][2] while also mentioning to use type hints responsibly. Can someone explain more about them and when they should be used and when not?

  [1]: http://lwn.net/Articles/650904/
  [2]: http://lwn.net/Articles/640359/


All Python Typing Solutions on Gang of Coders

Total of 37 Python Typing Solutions

How to specify "nullable" return type with type hints