web-dev-qa-db-fra.com

Comment connaître le type de retour de fonction et les types d'argument?

Bien que je sois conscient du concept de type canard de Python, j'ai parfois du mal avec le type d'arguments des fonctions, ou le type de la valeur de retour de la fonction.

Maintenant, si j'ai écrit la fonction moi-même, je connais les types. Mais que se passe-t-il si quelqu'un veut utiliser et appeler mes fonctions, comment doit-il connaître les types? Je mets généralement des informations de type dans la docstring de la fonction (comme: "...the id argument should be an integer..." Et "... the function will return a (string, [integer]) Tuple.")

Mais est-ce que la recherche des informations dans la docstring (et la mise là, en tant que codeur) est vraiment la façon dont cela est censé être fait?

Edit: Alors que la majorité des réponses semblent se diriger vers "oui, documentez!" Je pense que ce n'est pas toujours très facile pour les types "complexes".
Par exemple: comment décrire de manière concise dans une docstring qu'une fonction retourne une liste de tuples, avec chaque Tuple de la forme (node_id, node_name, uptime_minutes) et que les éléments sont respectivement une chaîne, une chaîne et un entier?
La documentation docstring PEP ne donne aucune directive à ce sujet.
Je suppose que le contre-argument sera que dans ce cas, les classes doivent être utilisées, mais je trouve python très flexible car il permet de contourner ces choses en utilisant des listes et des tuples, c'est-à-dire sans classes.

pythontypes
58
Rabarberski

Et bien les choses ont un peu changé depuis 2011! Maintenant, il y a type hints in Python 3.5 que vous pouvez utiliser pour annoter des arguments et renvoyer le type de votre fonction. Par exemple, ceci:

def greeting(name):
  return 'Hello, {}'.format(name)

peut maintenant être écrit comme ceci:

def greeting(name: str) -> str:
  return 'Hello, {}'.format(name)

Comme vous pouvez maintenant voir les types, il existe une sorte de vérification de type statique facultative qui vous aidera, vous et votre vérificateur de type, à étudier votre code.

pour plus d'explications, je suggère de jeter un œil au billet de blog sur les indices de type dans blog PyCharm .

68
Rsh

C'est ainsi que fonctionnent les langages dynamiques. Cependant, ce n'est pas toujours une bonne chose, surtout si la documentation est médiocre - quelqu'un a essayé d'utiliser un framework python mal documenté? Parfois, vous devez revenir à la lecture de la source.

Voici quelques stratégies pour éviter les problèmes de frappe de canard:

  • créer une langue pour votre domaine problématique
  • cela vous aidera à nommer les choses correctement
  • utiliser des types pour représenter des concepts dans la langue de votre domaine
  • nommer les paramètres de fonction en utilisant le vocabulaire de la langue du domaine

En outre, l'un des points les plus importants:

  • garder les données aussi locales que possible!

Il ne devrait y avoir que quelques types bien définis et documentés transmis. Tout le reste devrait être évident en regardant le code: ne pas avoir de types de paramètres étranges venant de loin que vous ne pouvez pas comprendre en regardant à proximité du code ...

Relié, (et également lié aux docstrings), il existe une technique dans python appelé doctests. Utilisez-le pour documenter comment vos méthodes devraient être utilisées - et avoir une unité Nice tester la couverture en même temps!

16
Daren Thomas

Oui, vous devez utiliser docstrings pour rendre vos classes et fonctions plus conviviales pour les autres programmeurs:

Plus: http://www.python.org/dev/peps/pep-0257/#what-is-a-docstring

Certains éditeurs vous permettent de voir les docstrings lors de la frappe, ce qui facilite vraiment le travail.

6
Maciej Ziarko

J'ai assisté à un cours de coursera, il y avait une leçon dans laquelle, on nous a enseigné la recette du design.

Sous le format docstring, j'ai trouvé preety utile.

 zone de déf. (base, hauteur): 
 '' '(numéro, numéro) -> numéro # ** TypeContract ** 
 Renvoyer la zone d'un tring avec les dimensions base # ** Description ** 
 Et hauteur 
 
 >>> surface (10,5) # ** Exemple ** 
 25,0 
 >> (2,5,3) 
 3,75 
 '' '
 retour (base * hauteur)/2

Je pense que si les docstrings sont écrits de cette façon, cela pourrait aider beaucoup les développeurs.

Lien vers la vidéo [Regardez la vidéo] : https://www.youtube.com/watch?v=QAPg6Vb_LgI

4
murarisumit

Oui, ça l'est.

Dans Python une fonction ne doit pas toujours renvoyer une variable du même type (bien que votre code soit plus lisible si vos fonctions renvoient toujours le même type). Cela signifie que vous pouvez 'ne spécifiez pas un seul type de retour pour la fonction.

De la même manière, les paramètres ne doivent pas toujours être du même type également.

2
thomson_matt

Oui, car c'est un langage de type dynamique;)

Lisez ceci pour référence: PEP 257

1
Alois Cochard

Par exemple: comment décrire de manière concise dans une docstring qu'une fonction renvoie une liste de tuples, avec chaque Tuple de la forme (node_id, node_name, uptime_minutes) et que les éléments sont respectivement une chaîne, une chaîne et un entier?

Um ... Il n'y a pas de description "concise" de cela. C'est complexe. Vous l'avez conçu pour être complexe. Et cela nécessite une documentation complexe dans la docstring.

Désolé, mais la complexité est - enfin - complexe.

1
S.Lott

Docstrings (et documentation en général). Python 3 introduit des annotations de fonction (facultatives), comme décrit dans PEP 3107 (mais ne laissez pas de côté les docstrings)

0
Steven