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

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

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

[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

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

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.

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