Type hinting a collection of a specified type

155,554

Solution 1

Answering my own question; the TLDR answer is No Yes.

Update 2

In September 2015, Python 3.5 was released with support for Type Hints and includes a new typing module. This allows for the specification of types contained within collections. As of November 2015, JetBrains PyCharm 5.0 fully supports Python 3.5 to include Type Hints as illustrated below.

PyCharm 5.0 Code Completion using Type Hints

Update 1

As of May 2015, PEP0484 (Type Hints) has been formally accepted. The draft implementation is also available at github under ambv/typehinting.

Original Answer

As of Aug 2014, I have confirmed that it is not possible to use Python 3 type annotations to specify types within collections (ex: a list of strings).

The use of formatted docstrings such as reStructuredText or Sphinx are viable alternatives and supported by various IDEs.

It also appears that Guido is mulling over the idea of extending type annotations in the spirit of mypy: http://mail.python.org/pipermail/python-ideas/2014-August/028618.html

Solution 2

Update: please see other answers, this one is outdated.

Original Answer (2015):

Now that Python 3.5 is officially out, there is the Type Hints supporting module - typing and the relevant List "type" for the generic containers.

In other words, now you can do:

from typing import List

def my_func(l: List[int]):
    pass

Solution 3

As of Python 3.9, builtin types are generic with respect to type annotations (see PEP 585). This allows to directly specify the type of elements:

def my_func(l: list[int]):
    pass

Various tools may support this syntax earlier than Python 3.9. When annotations are not inspected at runtime, the syntax is valid using quoting or __future__.annotations.

# quoted
def my_func(l: 'list[int]'):
    pass
# postponed evaluation of annotation
from __future__ import annotations

def my_func(l: list[int]):
    pass

Solution 4

Type comments have been added since PEP 484

from . import Monitor
from typing import List, Set, Tuple, Dict


active_monitors = [] # type: List[Monitor]
# or
active_monitors: List[Monitor] = []

# bonus
active_monitors: Set[Monitor] = set()
monitor_pair: Tuple[Monitor, Monitor] = (Monitor(), Monitor())
monitor_dict: Dict[str, Monitor] = {'codename': Monitor()}

# nested
monitor_pair_list: List[Dict[str, Monitor]] = [{'codename': Monitor()}]

This is currently working for me on PyCharm with Python 3.6.4

Example Picture in Pycharm

Solution 5

With support from the BDFL, it's almost certain now that python (probably 3.5) will provide a standardized syntax for type hints via function annotations.

https://www.python.org/dev/peps/pep-0484/

As referenced in the PEP, there is an experimental type-checker (kind of like pylint, but for types) called mypy that already uses this standard, and doesn't require any new syntax.

http://mypy-lang.org/

Share:
155,554

Related videos on Youtube

Eric W.
Author by

Eric W.

Updated on December 20, 2021

Comments

  • Eric W.
    Eric W. over 2 years

    Using Python 3'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<int>):
        pass
    

    I know it's possible using Docstring...

    def my_func(l):
        """
        :type l: list[int]
        """
        pass
    

    ... but I prefer the annotation style if it's possible.

    • jonrsharpe
      jonrsharpe almost 10 years
      Have you tried using the same format in the function annotations? What happened?
    • Bakuriu
      Bakuriu almost 10 years
      @jonrsharpe It should raise an error because type object is not subscriptable when defining the function. Obviously you can use a string: def my_func(L: 'list[int]') but I don't know whether PyCharm will parse it as it parses the docstrings...
    • jonrsharpe
      jonrsharpe almost 10 years
      @Bakuriu yes, I meant 'list[int]', apologies if that wasn't clear.
    • Eric W.
      Eric W. almost 10 years
      It doesn't appear that PyCharm will parse it like it does docstrings.
  • Eric W.
    Eric W. over 9 years
    Update: It appears that type hinting to include support for generic types has made its way to PEP484 python.org/dev/peps/pep-0484
  • Splines
    Splines over 2 years
    This should now be the accepted answer.
  • Snympi
    Snympi over 2 years
    As confirmation of @Splines comment, this should now be the answer for Python > 3.9
  • ToolmakerSteve
    ToolmakerSteve over 2 years
    FWIW (because i didn't like squinting at blurry text in an image): The key take-away from that image is l: List[str]. Upvoted alecxe's answer, as that shows it in plain text.
  • wisbucky
    wisbucky about 2 years
    superseded in Python 3.9. See stackoverflow.com/questions/24853923/…
  • 9 Guy
    9 Guy about 2 years
    @wisbucky this entire answer section needs an update.