Meilleures pratiques pour les astuces de type en Python

Utiliser un langage dynamique est un plaisir temporaire, et le code est reconstruit dans le crématorium. Je pense que vous devez avoir entendu cette phrase. Comme les tests unitaires, même si l'écriture du code prend un peu de temps, cela en vaut la peine à long terme. Cet article explique comment mieux comprendre et utiliser les astuces de type Python.

1. Les indices de type ne sont valables qu'au niveau syntaxique.

Les indices de type (introduits depuis la PEP 3107) sont utilisés pour ajouter des types aux variables, paramètres, paramètres de fonction et leurs valeurs de retour, propriétés de classe et méthodes.

Les types de variables de Python sont dynamiques et peuvent être modifiés au moment de l'exécution pour ajouter des indices de type au code. Ils ne sont pris en charge qu'au niveau de la syntaxe et n'ont aucun impact sur l'exécution du code. L'interpréteur Python ignorera les indices de type lors de l'exécution du code. code.

Par conséquent, une fonction intuitive des indices de type consiste à améliorer la lisibilité du code, en permettant à l'appelant de transmettre plus facilement les paramètres d'entrée/sortie du type approprié et en facilitant la reconstruction du code.

Les types de base intégrés de Python peuvent être utilisés directement pour les indices de type :

Exemples d'indices de type pour les variables :

a: int = 3
b: float = 2.4
c: bool = True
d: list = ["A", "B", "C"]
e: dict = {"x": "y"}
f: set = {"a", "b", "c"}
g: tuple = ("name", "age", "job")

Indices de type pour les fonctions :

def add_numbers(x: type_x, y: type_y, z: type_z= 100) -> type_return:
return x + y + z

type_x, type_y, type_z, type_return ici peuvent être des types de base intégrés , ou Peut être un type personnalisé.

Indices de type de classe :

class Person:
first_name: str = "John"
last_name: str = "Does"
age: int = 31

2. Utilisez mypy pour vérifier les indices de type

S'il existe un tel morceau de code :

x: int = 2

x = 3.5

Il n'y aura aucune erreur lors de son exécution avec l'interpréteur Python :

Avec l'aide de Utilisez simplement mypy. Installez-le d'abord avec pip install mypy, puis utilisez mypy script.py :

Pour plus d'informations sur mypy, veuillez vous référer à l'article précédent. Mypy est un outil qui crée des Python. tapez des conseils très pratiques.

3. Avantages des astuces de type

Si l'interpréteur n'applique pas les astuces de type, pourquoi s'embêter à écrire des astuces de type ? Il est vrai que les indications de type ne changent pas la façon dont votre code s'exécute : Python est typé dynamiquement par nature, et il est peu probable que cela change. Cependant, du point de vue de l’expérience du développeur, les indications de type présentent de nombreux avantages.

(1) Utilisez des astuces de type, en particulier dans les fonctions, pour clarifier les types de paramètres et le type de résultats générés, ce qui est très facile à lire et à comprendre.

(2) Les astuces de type éliminent la surcharge cognitive et rendent le code plus facile à lire et à déboguer. Compte tenu des types d’entrées et de sorties, vous pouvez facilement déduire les objets et la manière dont ils sont appelés.

(3) Les astuces de type peuvent améliorer l'expérience d'édition de code. Les IDE peuvent s'appuyer sur la vérification de type pour analyser statiquement votre code et aider à détecter les erreurs potentielles (par exemple, transmettre des paramètres du mauvais type, appeler la mauvaise méthode, etc.). De plus, la saisie semi-automatique est fournie pour chaque variable en fonction des indications de type.

Vérification du type IDE

Vérification du type IDE

Complètement automatique après la vérification du type IDE

4. indice, ce n'est pas possible :

def my_dummy_function(l: list[float]):
 return sum(l)

Le typage de bibliothèque standard prend ce problème en considération, vous pouvez faire ceci :

from typing import List

def my_dummy_function(vector: List[float]):
 return sum(vector)

5 Utilisation de Dict

Si vous souhaitez afficher un tel type :

my_dict = {"name": "Somenzz", "job": "engineer"}

Avec l'aide de Dict. , vous pouvez définir le type comme ceci :

from typing import Dict
my_dict_type = Dict[str, str]
my_dict: my_dict_type = {"name": "Somenzz", "job": "engineer"}

6. Utilisation de TypedDict

Que devez-vous faire si vous devez demander un tel type ?

d = {"name": "Somenzz", "interests": ["chess", "tennis"]}

Avec l'aide de TypedDict, vous pouvez faire ceci :

TypedDict

7. Utilisation d'Union

À partir de Python 3.10, Union est remplacée par | maintenant équivalent à X|Y.

Union[X, Y] (ou X | Y) signifie X ou Y.

Supposons que votre fonction doive lire un fichier du répertoire cache et charger le modèle Torch. Cet emplacement du répertoire de cache peut être une valeur de chaîne (telle que /home/cache), ou il peut s'agir d'un objet Path de la bibliothèque Pathlib. Dans ce cas, le code est le suivant :

def load_model(filename: str, cache_folder: Union[str, Path]):
if isinstance(cache_folder, Path):
cache_folder = str(cache_folder)

model_path = os.join(filename, cache_folder)
model = torch.load(model_path)
return model

8.

Lorsque vous devez transmettre Lors de la saisie d'une fonction en tant que paramètre, l'indice de type de ce paramètre peut être Callable.

from typing import Callable

def sum_numbers(x: int, y: int) -> int:
return x + y

def foo(x: int, y: int, func: Callable) -> int:
output = func(x, y)
return output

foo(1, 2, sum_numbers)

Vous pouvez également spécifier une liste de paramètres pour de tels paramètres de fonction, ce qui est vraiment puissant :

Syntaxe :

Callable[[input_type_1, ...], return_type]

Exemple :

def foo(x: int, y: int, func: Callable[[int, int], int]) -> int:
output = func(x, y)
return output

9、Any 用法

当你传入的参数可以为任何类型的时候，就可以使用 Any

def bar(input: Any):
...

10、Optional 用法

如果你的函数使用可选参数，具有默认值，那么你可以使用类型模块中的 Optional 类型。

from typing import Optional

def foo(format_layout: Optional[bool] = True):
...

11、Sequence 用法

Sequence 类型的对象是可以被索引的任何东西：列表、元组、字符串、对象列表、元组列表的元组等。

from typing import Sequence

def print_sequence_elements(sequence: Sequence[str]):
for i, s in enumerate(s):
print(f"item {i}: {s}"

12、Tuple 用法

Tuple 类型的工作方式与 List 类型略有不同，Tuple 需要指定每一个位置的类型：

from typing import Tuple
t: Tuple[int, int, int] = (1, 2, 3)

如果你不关心元组中每个元素的类型，你可以继续使用内置类型 tuple。

t: tuple = (1, 2, 3, ["cat", "dog"], {"name": "John"})

最后的话

类型提示在代码之上带来了额外的抽象层：它们有助于记录代码，澄清关于输入/输出的假设，并防止在顶部执行静态代码分析 (mypy) 时出现的隐蔽和错误。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!