Maîtriser les indices de type dans PyCharm

Avec PyCharm, l'inférence de type est basée sur les commentaires dans docstring.

def foo(x):
    """
    :rtype: list of str
    """
    return x

def bar(x):
    a = foo(x)
    a[0].  # <-À ce stade, la méthode string est un candidat

docstring

Il semble accepter comment écrire Sphinx et Epytext, mais comme Sphinx est plus courant en Python, apprenons-le.

def repeat(x, y):
    """
    :param str x: value to repeat
    :type  y: int
    :param y: number of repeat
    :rtype:   str
    :return:  repeated string
    """
    return x * y

L'argument peut être écrit sous la forme : param type name: ou : type argument name: type. Écrivez la valeur de retour sous la forme «: rtype:».

Déclaration de type

Vous pouvez approximativement comprendre comment l'écrire en regardant le fichier StdlibTypes2.properties. Ce fichier se trouve dans le répertoire / Applications / PyCharm 2.7.2 EAP.app / helpers sur Mac.

Voici quelques extraits.

__builtin__.locals = \
  :rtype: dict of (string, unknown)

__builtin__.filter = \
  :type function_or_none: collections.Callable or None \n\
  :type sequence: collections.Iterable of T \n\
  :rtype: list of T \n\

__builtin__.enumerate.__init__ = \
  :type iterable: collections.Iterable of T \n\
  :type start: int or long \n\
  :rtype: enumerate of (int, T) \n\

__builtin__.enumerate.next = \
  :rtype: (int, T) \n\

__builtin__.dict.__init__ = \
  :type seq: collections.Iterable of (T, V) \n\
  :rtype: dict of (T, V) \n\

__builtin__.dict.__getitem__ = \
  :type y: T \n\
  :rtype: V \n\

__builtin__.dict.items = \
  :rtype: list of (T, V) \n\

Les types complexes peuvent être écrits comme (int, str) uniquement pour les taples, et sont représentés en utilisant ʻof like dict of (T, V) ʻautrement.

Il semble que l'argument type puisse utiliser n'importe quelle lettre supérieure, pas seulement T.

Lors du retour d'un type général, il semble bon d'utiliser ABC dans les collections sous la forme de de T.

Si vous pouvez recevoir plus d'une personne, cela semble se connecter avec ʻoupourʻint ou None``.

Taper des indices vers d'autres variables

#: :type: int
x = unknown()

Vous pouvez donner un indice en ajoutant un commentaire comme celui-ci. Mais

#: ????
a, b = unknwon()

Je ne sais toujours pas comment faire allusion dans ce cas. Vous pouvez le recevoir une fois de suite, mais c'est gênant, il semble donc préférable de définir: rtype: correctement du côté de la fonction.