Comment indiquer à PyCharm le type de paramètre attendu ?

Question

Quand il s'agit de constructeurs, d'affectations et d'appels de méthodes, l'IDE PyCharm est plutôt bon pour analyser mon code source et déterminer le type de chaque variable. J'aime quand il est bon, parce qu'il me donne de bonnes informations sur la complétion du code et les paramètres, et il me donne des avertissements si j'essaie d'accéder à un attribut qui n'existe pas.

Mais lorsqu'il s'agit de paramètres, il ne sait rien faire. Les listes déroulantes de complétion de code ne peuvent rien afficher, car elles ne savent pas de quel type sera le paramètre. L'analyse du code ne peut pas rechercher les avertissements.

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

peasant = Person("Dennis", 37)
# PyCharm knows that the "peasant" variable is of type Person
peasant.dig_filth()   # shows warning -- Person doesn't have a dig_filth method

class King:
    def repress(self, peasant):
        # PyCharm has no idea what type the "peasant" parameter should be
        peasant.knock_over()   # no warning even though knock_over doesn't exist

King().repress(peasant)
# Even if I call the method once with a Person instance, PyCharm doesn't
# consider that to mean that the "peasant" parameter should always be a Person

Cela a un certain sens. Les autres sites d'appel pourraient passer n'importe quoi pour ce paramètre. Mais si ma méthode attend d'un paramètre qu'il soit de type, disons, pygame.Surface j'aimerais pouvoir l'indiquer à PyCharm d'une manière ou d'une autre, afin qu'il puisse me montrer tous les éléments suivants Surface dans sa liste déroulante de complétion de code, et de mettre en évidence les avertissements si j'appelle la mauvaise méthode, etc.

Y a-t-il un moyen de donner un indice à PyCharm, et de dire "psst, ce paramètre est censé être de type X" ? (Ou peut-être, dans l'esprit des langages dynamiques, "ce paramètre est censé ressembler à un X" ? Cela me conviendrait parfaitement).

---

EDITAR: La réponse de CrazyCoder, ci-dessous, fait l'affaire. Pour les nouveaux venus qui, comme moi, veulent un résumé rapide, le voici :

class King:
    def repress(self, peasant):
        """
        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.
        """
        peasant.knock_over()   # Shows a warning. And there was much rejoicing.

La partie pertinente est la suivante @type peasant: Person de la docstring.

Si vous allez également dans Fichier > Paramètres > Outils intégrés Python et que vous définissez "Docstring format" sur "Epytext", alors la fonction Affichage > Recherche rapide de documentation de PyCharm imprimera joliment les informations des paramètres au lieu d'imprimer toutes les lignes @ telles quelles.

Answer 1

Oui, vous pouvez utiliser un format de documentation spécial pour les méthodes et leurs paramètres afin que PyCharm puisse connaître le type. Version récente de PyCharm supporte les formats de documents les plus courants .

Par exemple, PyCharm extrait les types de @param style commentaires .

Voir aussi reStructuredText y conventions de la docstring (PEP 257).

Les annotations Python 3 constituent une autre option.

S'il vous plaît se référer à la section de la documentation de PyCharm pour plus de détails et des échantillons.

Answer 2

Si vous utilisez Python 3.0 ou une version ultérieure, vous pouvez également utiliser des annotations sur les fonctions et les paramètres. PyCharm les interprétera comme le type que les arguments ou les valeurs de retour doivent avoir :

class King:
    def repress(self, peasant: Person) -> bool:
        peasant.knock_over() # Shows a warning. And there was much rejoicing.

        return peasant.badly_hurt() # Lets say, its not known from here that this method will always return a bool

C'est parfois utile pour les méthodes non publiques, qui n'ont pas besoin d'une docstring. En outre, ces annotations sont accessibles au code :

>>> King.repress.__annotations__
{'peasant': <class '__main__.Person'>, 'return': <class 'bool'>}

Mise à jour : A partir de PEP 484 qui a été acceptée pour Python 3.5, c'est aussi la convention officielle pour spécifier les types d'arguments et de retours en utilisant des annotations.

Answer 3

PyCharm extrait les types d'une chaîne pydoc @type. Voir la documentation de PyCharm aquí y aquí et Docs Epydoc . Il se trouve dans la section "legacy" de PyCharm, il lui manque peut-être certaines fonctionnalités.

class King:
    def repress(self, peasant):
        """
        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.
        """
        peasant.knock_over()   # Shows a warning. And there was much rejoicing.

La partie pertinente est la suivante @type peasant: Person de la docstring.

Mon intention n'est pas de voler des points à CrazyCoder ou à l'auteur de la question initiale, mais bien de leur en donner. J'ai simplement pensé que la réponse simple devait être placée dans un emplacement "réponse".

Answer 4

J'utilise PyCharm Professional 2016.1 pour écrire du code py2.6-2.7, et j'ai trouvé qu'en utilisant reStructuredText je peux exprimer les types d'une manière plus succincte :

class Replicant(object):
    pass

class Hunter(object):
    def retire(self, replicant):
        """ Retire the rogue or non-functional replicant.
        :param Replicant replicant: the replicant to retire.
        """
        replicant.knock_over()  # Shows a warning.

Voir : https://www.jetbrains.com/help/pycharm/2016.1/type-hinting-in-pycharm.html#legacy

Answer 5

Vous pouvez également demander un type et Pycharm le déduira :

def my_function(an_int):
    assert isinstance(an_int, int)
    # Pycharm now knows that an_int is of type int
    pass