Typage pour utilisation ultérieure

Bonjour,
Je cherche à éclaircir un point sombre de Python. En utilisant le typage des variables, comment puis-je typer une variable sans l’initialiser au préalable ?

Dans l’exemple ci-dessous, ma propriété active_user est sensé être un User, mais elle s’initialisera plus tard dans l’exécution du programme.

Code:

---

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

class MainApp: """     Main App class     """   def __init__(self): """         Constructor         """ self.users: dict[User, Vault] = {} self.active_user: User = None #…

---

Je pourrais mettre Optional[User] en typage, mais dans ce cas, PyLance ronchonne sur la suite du code, car il ne peut pas être possible d’avoir None.

Je pourrais aussi utiliser des assert, mais j’en suis pas fan.

Y a-t-il une piste que je puisse creuser ?

Merci,

Bonne journée !

Et Ellipsis à la place de None ?

Bonjour

Bizarre cette notion de typage chez Python, parce qu'il n'y a aucun contrôle: c'est l'affectation qui détermine le type,et non la déclaration de type:

Code:

---

1 2 3

a:int = 0.5 type(a) float

---

Et donc:

Code:

---

1 2 3

b:int = None type(b) NoneType

---

Conclusion: est-on vraiment sûr que ça apporte quelque chose?

Citation:

---

Envoyé par Raylemon

Bonjour,
Je cherche à éclaircir un point sombre de Python. En utilisant le typage des variables, comment puis-je typer une variable sans l’initialiser au préalable ?

Dans l’exemple ci-dessous, ma propriété active_user est sensé être un User, mais elle s’initialisera plus tard dans l’exécution du programme.

Code:

---

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

class MainApp: """     Main App class     """   def __init__(self): """         Constructor         """ self.users: dict[User, Vault] = {} self.active_user: User = None #…

---

Je pourrais mettre Optional[User] en typage, mais dans ce cas, PyLance ronchonne sur la suite du code, car il ne peut pas être possible d’avoir None.

Je pourrais aussi utiliser des assert, mais j’en suis pas fan.

Y a-t-il une piste que je puisse creuser ?

Merci,

Bonne journée !

---

On peut typer sans initialiser sans aucun soucis.

Code:

---

1 2 3

mon_integer: int ma_string: str mon_instance_de_classe_toto: Toto

---

Et si un attribut ou une variable peuvent être de plusieurs types différents (au choix) :

Code:

---

1 2	mon_int_ou_ma_string: int | str toto: int | str | None

---

Hello,

@tyrtamos,


Faire du typing sans vérificateur de types, ça ne sert à rien ! Je te propose de regarder du côté de MyPy, C'est un outil qui vérifie si les données que j'utilise dans mon code Python sont correctes. C'est super utile pour éviter les erreurs et pour s'assurer que mon code fonctionne comme je le souhaite.

Supposons que tu veuilles écrire une fonction qui prend deux nombres en entrée et renvoie leur somme. Avec Mypy, tu peux définir le type des entrées, par exemple entiers, pour s'assurer que les entrées sont bien des nombres entiers. Si quelqu'un appelle cette fonction avec des entrées qui ne sont pas des entiers, Mypy le signalera lors de la vérification du type, ce qui te permettra de corriger le problème avant même d'exécuter le code.

Bonjour

Citation:

---

Envoyé par Arioch

On peut typer sans initialiser sans aucun soucis.

---

Ce serait logique, mais après la déclaration de typage, la variable n'existe toujours pas (elle n'a donc pas de type!), et elle n'existera qu'à la 1ère affectation:

Code:

---

1 2 3 4 5 6

e:int type(e) --------------------------------------------------------------------------- NameError Traceback (most recent call last) ----> 1 type(e) NameError: name 'e' is not defined

---

Citation:

---

Envoyé par Arioch

Et si un attribut ou une variable peuvent être de plusieurs types différents (au choix) :

---

Chez moi, ça ne marche pas:

Code:

---

1 2 3 4 5

toto: int | str --------------------------------------------------------------------------- TypeError Traceback (most recent call last) ----> 1 toto: int | str TypeError: unsupported operand type(s) for |: 'type' and 'type'

---

Je suis sous Python 3.9: est-ce que ça s'arrange avec un Python plus récent?

Code:

---

1 2 3 4 5 6 7 8 9 10 11

Python 3.9.16 (main, Jan 7 2023, 22:12:13) [GCC 11.3.0] on linux Type "help", "copyright", "credits" or "license" for more information. >>> toto: int | str Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: unsupported operand type(s) for |: 'type' and 'type' >>> >>> >>> from typing import Union >>> >>> toto: Union[int, str]

---

Citation:

---

Envoyé par tyrtamos

Je suis sous Python 3.9: est-ce que ça s'arrange avec un Python plus récent?

---

En effet. C'est arrivé avec la 3.10.

A l'époque de la 3.9 et des versions antérieures, j'utilisais le module typing et j'importais Optional

Pour faire ceci :

Code:

---

toto: int | str

---

Je faisais alors :

Code:

---

1 2 3

from typing import Optional   toto: Optional[int, str]

---

Citation:

---

Envoyé par tyrtamos

après la déclaration de typage, la variable n'existe toujours pas (elle n'a donc pas de type!)

---

J'utilise VsCode au quotidien, boulot ou perso.

Typer ses attributs ou variables permet d'avoir rapidement une alerte si on affecte une valeur qui est d'un typage différent de celui déclaré.

Comme le mentionne fred1599 un peu plus haut, si on se gourre sur ce point, mypy ne sera pas content et l'indiquera clairement.

Et si, comme moi, tu es habitué à bosser sur le même fichier en parallèle avec tes collègues, tu es bien content d'avoir le typage, et eux aussi.

"Ah mais c'est un int qu'il faut renvoyer ? Bordel, j'étais parti sur une chaîne moi !"
"J'ai pourtant bien mis le bon typage, na !"

Et c'est pratique pour les docstrings où, si tu énumères les arguments en E/S, bah t'as pas besoin de spécifier le typage dans ce que tu mets en commentaires.

Exemple :

Code:

---

1 2 3 4 5 6 7 8 9 10 11

def classifications(self, keywords: str, labels: list[str]) -> list[dict[str, str | list[str]]]: '''Method Description.         groups keywords and labels in a list.                 Args:             keywords: the keywords.             labels: list of different labels.                 Returns:             list of two dicts with keywords and labels values.         '''

---

Citation:

---

Code:

---

toto: int | str

---

Je faisais alors :

Code:

---

1 2 3

from typing import Optional   toto: Optional[int, str]

---

---

Optional permet de définir un type spécifique ou None, ce n'est pas ce que je comprends dans toto: int | str car on ne parle pas de l'option possible None non plus.

D'ailleurs on peut faire un test rapide

Code:

---

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

>>> from typing import Optional >>> toto: Optional[int, str] Traceback (most recent call last): File "<stdin>", line 1, in <module> File "/usr/local/lib/python3.9/typing.py", line 277, in inner return func(*args, **kwds) File "/usr/local/lib/python3.9/typing.py", line 354, in __getitem__ return self._getitem(self, parameters) File "/usr/local/lib/python3.9/typing.py", line 478, in Optional arg = _type_check(parameters, f"{self} requires a single type.") File "/usr/local/lib/python3.9/typing.py", line 166, in _type_check raise TypeError(f"{msg} Got {arg!r:.100}.") TypeError: typing.Optional requires a single type. Got (<class 'int'>, <class 'str'>).

---

Ceci fonctionne :

Code:

---

toto: int|str|None

---

En Python <3.10, j'aurais fait :

Code:

---

toto: Optional[int, str, None]

---

Et quand tu ne sais pas trop ce que tu vas coller dans ta variable ou ton attribut, au bout d'un moment, moi hein...

Code:

---

toto: Any

---

Citation:

---

Envoyé par Arioch

Ceci fonctionne :

En Python <3.10, j'aurais fait :

Code:

---

toto: Optional[int, str, None]

---

---

Bah non !

voir ma réponse précédente !

My bad.

Bon, ça fait un moment que je bosse en 3.10. Me souviens plus exactement comment je faisais.

Citation:

---

Envoyé par Arioch

My bad.

Bon, ça fait un moment que je bosse en 3.10. Me souviens plus exactement comment je faisais.

---

Sans doute avec le mot clé Union comme indiqué précédemment dans mon exemple. Si on ajoutait None ça donnerait Union[int, str, None]

Oui, tu as raison.

Pour moi, le typage me sert à clarifier les objets, et utiliser IntelliSense efficacement. Après, je suis d’accord que ça ne sert à rien en fonctionnement. J’aime juste ne pas avoir de message d’erreur de PyLance et MyPy à cause d’une initialisation qui ne se fera pas immédiatement.

Pour le moment, j’ai mis une série d’assert pour que Pylance soit content...

Mais si un expert Python passe par ici et qu’une solution existe, je reste preneur.

Pour info, je travaille sur Python 3.11 et VSCode (bizarrement, PyCharm ne ronchonne pas sur l’Optional sans assert, contrairement à VSCode)

Je vais me répéter mais est-ce que Ellipsis ne ferait pas l'affaire ? J'ai pas de quoi tester donc je pose la question .

Code:

---

self.active_user: User = ...

---

Salut,

J'avais essayé le typage avec Python mais il me semble que cela n'avait pas apporté grand chose...
Je m'attendais à ce que cela fasse comme avec TypeScript

Mais apparemment pour que cela fonctionne il fallait installer un module (et avoir un python >= à 3.10) si j'ai bien compris ?


- Est-ce que le module permet d'améliorer l'autocomplétion ?
Je suppose que pour cela il faudrait que les variables des scripts du projet soient typées ?

- Si oui, alors pour les anciens scripts (librairie ou autre, pas forcément les notre) comment peut-on faire ?
Est-ce qu'il y a un équivalent aux fichiers de déclaration de TypeScript ?


Bon, la détection des erreurs de type c'est déjà un bon début...

Citation:

---

Envoyé par josmiley

Je vais me répéter mais est-ce que Ellipsis ne ferait pas l'affaire ? J'ai pas de quoi tester donc je pose la question .

Code:

---

self.active_user: User = ...

---

---

Pardon, je n’ai pas répondu à cette question. Non, hélas ça ne marche pas :( Ou alors je ne sais pas l’utiliser. J’avoue que je ne connaissais pas Ellipsis ailleurs que dans les listes…