comment affiner le cast d'une fonction

Bonjour a tous,

Afin d'avoir un code plus simple a lire, lorsque j'écris un code je rajoute toujours le cast attendu, et de retour. Par exemple :

Code:

---

1 2	def ReturnList(iVar:int)->list: return ['a','b']

---

Seulement j'aimerai savoir si je peux affiner mon casting en disant que c'est une liste de str ou d'objets etcc.. j'ai essayé ceci en vain

Code:

---

1 2	def ReturnList(iVar:int)->list[str]: return ['a','b']

---

mais j'ai l'erreur suivante

Code:

---

TypeError: 'type' object is not subscriptable

---

Est ce que quelqu'un a une astuce de comment faire, si cela est possible?

Bonjour

Je pense que tu n'utilise pas le mot "casting" a bon escient.

Un cast c'est un changement de type. Exemple : tu calcules 5/2.5. Le nombre 5 est un int et 2.5 est un float. Si ton langage ne définit que la division entre les float et les float et entre les int et les int (et pas autres choses), alors si on lui demande de calculer 5/2.5 alors il y a 2 possibilité :
- soit le compilateur fait un cast (un changement de type) implicite (et transforme le int 5 en flotant 5.0, pour pouvoir ensuite faire l'opération)
- soit le compilateur ne le fait pas, te renvoie une erreur, et donc tu dois faire le cast explicitement en écrivant par exemple float(5)/2.5

Ici on parlera juste du type de retour de ta fonction. Ce n'est pas un cast.

Ensuite pour ta question je pense qu'ici tu trouveras ton bonheur :
https://docs.python.org/3/library/typing.html

Salut,

Il faut faire ->list([str, str]):.

Surprenant quand même, je pensais que Python ignorait totalement les annotations.

D'autant plus que l'on peut mettre ce que l'on veut:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

>>> def foo(var:int)->list([str, str]): ... return ['a', 'b'] ... >>> foo(5) ['a', 'b'] >>> foo('tyrgr') ['a', 'b'] >>> def foo(var:int)->list([int, int]): ... return ['a', 'b'] ... >>> foo({"a": 42}) ['a', 'b']

---

Bonjour

Citation:

---

Envoyé par VinsS

Surprenant quand même, je pensais que Python ignorait totalement les annotations.

D'autant plus que l'on peut mettre ce que l'on veut:

---

Oui, il ignore ces annotations dans le sens où il ne vérifie pas que le type retourné (ainsi que les types reçus) correspondent à la signature décrite. Ainsi cette fonction peut très bien retourner None sans qu'il râle.
Mais si on utilise cette syntaxe, on est quand-même obligés de mettre un des mots clefs prévus à cet effet. Interdit d'écrire par exemple def f() -> truc. Donc il ne l'ignore pas entièrement.

Et peut-être que dans le futur il ne l'ignorera plus du tout et le code devra impérativement se conformer à la signature si celle-ci est présente.

Salut,

Indiquer les types c'est intéressant car certains outils en tiennent compte et nous avertissent en cas de non respect...
Cela me fait penser aux outils qui existent pour JS...

Je me suis demandé si l'interpréteur pouvait en tenir compte pour éventuellement optimiser mais j'en doute...