Comment puis-je savoir quel type PyCharm un paramètre devrait être?

Question

En ce qui concerne les constructeurs, et les affectations et les appels de méthode, l'PyCharm IDE est assez bon à analyser mon code source et déterminer quel type de chaque variable doit être. Je l'aime quand il est vrai, parce que cela me donne bonne fin de code et d'information des paramètres, et il me donne des avertissements si je tente d'accéder à un attribut qui n'existe pas.

Mais quand il s'agit de paramètres, il ne sait rien. Les listes déroulantes code d'achèvement ne peut pas afficher quoi que ce soit, parce qu'ils ne savent pas quel type le paramètre sera. L'analyse de code ne peut pas rechercher des 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 fait une certaine quantité de sens. D'autres sites d'appels pourraient passer quoi que ce soit pour ce paramètre. Mais si ma méthode attend un paramètre à être de type, disons, pygame.Surface, je voudrais être en mesure d'indiquer que, pour PyCharm en quelque sorte, il peut me montrer tous les attributs de Surface dans son menu déroulant-complétion de code, et les avertissements en surbrillance si J'appelle la mauvaise méthode, et ainsi de suite.

Est-il possible que je peux donner PyCharm un indice, et 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é charlatan comme un X »? Je serais bien avec ça.)

---

EDIT: La réponse de CrazyCoder, ci-dessous, le tour est joué. Pour les nouveaux arrivants comme moi qui veulent le résumé rapide, la 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 ligne de @type peasant: Person du docstring.

Si vous allez aussi Fichier> Paramètres> Python Outils intégrés et ensemble « format docstring » à « Epytext », puis View PyCharm> Documentation rapide Recherche sera très-imprimer les informations de paramètres au lieu d'imprimer tous les @ trapézoidale comme -is.

Answer 1

Oui, vous pouvez utiliser le format de la documentation spéciale pour les méthodes et leurs paramètres afin que PyCharm peut connaître le type. Récente version PyCharm supporte les formats doc les plus communs .

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

Voir aussi reStructuredText et docstring de conventions (le PEP 257).

Une autre option est Python 3 annotations.

à la section de documentation de PyCharm plus de détails et des échantillons.

Answer 2

Si vous utilisez Python 3.0 ou version ultérieure, vous pouvez également utiliser des annotations sur les fonctions et paramètres. PyCharm interprétera ceux-ci comme le type des arguments ou des valeurs de retour devraient 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

Parfois, cela est utile pour les méthodes non publiques, qui ne nécessitent pas un docstring. Comme un avantage supplémentaire, ces annotations sont accessibles par code:

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

Mise à jour : Au PEP 484 , qui a été accepté pour Python 3.5, il est également la convention officielle pour spécifier les types d'arguments et de retour à l'aide des annotations.

Answer 3

Les types de PyCharm d'une chaîne pydoc @type. Voir PyCharm docs ici et ici et Epydoc docs . Il est dans la section « héritage » de PyCharm, peut-être il manque 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 ligne de @type peasant: Person du docstring.

Mon intention est de ne pas voler des points de CrazyCoder ou le questionneur d'origine, par tous les moyens de leur donner leurs points. Je pensais juste que la réponse simple devrait être dans un emplacement « réponse ».

Answer 4

J'utilise PyCharm Professional 2016,1 écrire du code py2.6-2.7, et je trouve que l'utilisation que je reStructuredText peut exprimer les types d'une manière plus succint:

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 faisant allusion en pycharm.html héritage #

Answer 5

Vous pouvez également assert pour un type et PyCharm va le déduire:

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