Discussion :

[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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 !

[josmiley]

Et Ellipsis à la place de None ?

[tyrtamos]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
a:int = 0.5
type(a)
float

Et donc:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
b:int = None
type(b)
NoneType

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

[Arioch]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[fred1599]

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.

[tyrtamos]

Bonjour

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

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

Chez moi, ça ne marche pas:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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?

[fred1599]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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]

[Arioch]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

toto: int | str

Je faisais alors :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
from typing import Optional
 
toto: Optional[int, str]

[Arioch]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.
        '''

[fred1599]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

toto: int | str

Je faisais alors :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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'>).

[Arioch]

Ceci fonctionne :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

toto: int|str|None

En Python <3.10, j'aurais fait :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

toto: Any

[fred1599]

Ceci fonctionne :

En Python <3.10, j'aurais fait :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

toto: Optional[int, str, None]

Bah non !

voir ma réponse précédente !

[Arioch]

My bad.

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

[fred1599]

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]

[Arioch]

Oui, tu as raison.

[Raylemon]

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)

[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 :

Sélectionner tout - Visualiser dans une fenêtre à part

self.active_user: User = ...

[Beginner.]

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...

[Raylemon]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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…