Quatre techniques de développement déductif Python pour rendre votre code plus efficace

Pour la science des données, Python est généralement largement utilisé pour le traitement et la transformation des données. Il fournit de puissantes fonctions de traitement de la structure des données pour rendre le traitement des données plus flexible. Que signifie ici « flexibilité » ? Pour obtenir le même résultat en Python, nous avons toujours des méthodes différentes et devons choisir celle qui est facile à utiliser, qui fait gagner du temps et donne un meilleur contrôle.

Il est impossible de maîtriser toutes ces méthodes. Voici donc une liste de 4 astuces Python que vous devez connaître lorsque vous travaillez avec tout type de données.

La compréhension de liste est un moyen élégant et très convivial de créer des listes. Par rapport aux boucles for et aux instructions if, les compréhensions de liste ont une syntaxe beaucoup plus courte pour créer une nouvelle liste basée sur les valeurs d'une liste existante. Voyons donc comment cette fonctionnalité obtient une copie de la liste.

Copier une liste à l'aide des compréhensions de liste

Parfois, il est nécessaire de créer une copie d'une liste existante. La réponse la plus simple est .copy(), qui vous permet de copier le contenu d'une liste vers une autre (nouvelle) liste.

Par exemple, une liste d'entiers original_list.

original_list = [10,11,20,22,30,34]

Cette liste peut être copiée simplement en utilisant la méthode .copy().

duplicated_list = original_list.copy()

Les compréhensions de listes vous donnent exactement le même résultat. Copier une liste est un excellent exemple de compréhension des compréhensions de listes.

Regardez le code ci-dessous.

duplicated_list = [item for item in original_list]

Cela ne veut pas dire qu'il est préférable d'utiliser la compréhension de liste lors de la copie d'une liste, mais cela veut dire que ce cas est le meilleur pour introduire la méthode de travail de compréhension de liste.

Ensuite, voyons comment la compréhension de listes facilite la vie lors de l'exécution d'opérations mathématiques sur chaque élément d'une liste.

Multipliez les éléments d'une liste

La manière la plus simple ou la plus directe de multiplier est d'utiliser l'opérateur de multiplication, qui est *

Par exemple, vous souhaitez multiplier chaque élément de la liste par un scalaire (c'est-à-dire le nombre 5) . Vous ne pouvez certainement pas utiliser original_list*5 ici car cela créerait 5 copies de la liste.

Dans ce scénario, la meilleure réponse est une compréhension de liste comme indiqué ci-dessous.

original_list = [10,11,20,22,30,34]
 multiplied_list = [item*5 for item in original_list]
 
 # Output
 [50, 55, 100, 110, 150, 170]

L'opération ici ne se limite pas à multiplier un nombre. Des opérations complexes peuvent être effectuées sur chaque élément de la liste d'origine.

Par exemple, supposons que vous souhaitiez calculer le cube de la racine carrée de chaque terme. Vous pouvez le résoudre en une seule ligne.

multiplied_list = [math.sqrt(item)**3 for item in original_list]
 
 # Output
 [31.6227766016838,
36.4828726939094,
89.4427190999916,
103.18914671611546,
164.31676725154983,
198.25236442474025]

La fonction sqrt utilisée pour calculer la racine carrée d'un nombre appartient à la bibliothèque math, donc dans ce cas elle doit être importée avant de l'utiliser.

Semblable aux fonctions intégrées présentées ci-dessus, il est également possible d'utiliser des fonctions définies par l'utilisateur sur chaque élément de la liste.

Par exemple, une fonction simple comme indiqué ci-dessous.

def simple_function(item):
item1 = item*10
item2 = item*11
return math.sqrt(item1**2 + item2**2)

peut appliquer cette fonction définie par l'utilisateur à chaque élément de la liste.

multiplied_list = [simple_function(item) for item in original_list]
 
 # Output
 [148.66068747318505,
163.52675622050356,
297.3213749463701,
327.0535124410071,
445.9820624195552,
505.4463374088292]

Les compréhensions de listes sont encore plus utiles dans des scénarios du monde réel. Habituellement, dans les tâches d'analyse, vous devez supprimer certains types d'éléments d'une liste, comme l'élimination des éléments nan. La compréhension de listes est l’outil parfait pour ces tâches.

Supprimer des éléments d'une liste

Le filtrage des données en fonction de critères spécifiques est l'une des tâches courantes pour sélectionner l'ensemble de données requis, la même logique est également utilisée dans la compréhension des listes.

Supposons que vous ayez la liste des numéros mentionnés ci-dessous.

original_list = [10, 22, -43, 0, 34, -11, -12, -0.1, 1]

Vous souhaitez conserver uniquement les valeurs positives de cette liste. Donc logiquement, vous souhaitez conserver uniquement les éléments qui sont évalués à VRAI pour les éléments conditionnels > 0. La clause

new_list = [item for item in original_list if item > 0]
 
 # Output
 [10, 22, 34, 1]

if est utilisée pour supprimer les valeurs négatives. Vous pouvez appliquer n'importe quelle condition en utilisant la clause if pour supprimer n'importe quel élément de la liste.

Par exemple, lorsque vous souhaitez supprimer tous les termes dont le carré est inférieur à 200, il vous suffit de mentionner le terme conditionnel **2 > 200 dans la synthèse de liste, comme indiqué ci-dessous.

new_list = [item for item in original_list if item**2 > 200]
 
 # Output
 [22, -43, 34]

Lorsqu'il s'agit d'ensembles de données réels, les conditions de filtrage des éléments de liste peuvent être beaucoup plus complexes, cette méthode est rapide et facile à comprendre.

Convertissez deux listes en paires clé-valeur de dictionnaire à l'aide de dict()

Parfois, il est nécessaire de créer un dictionnaire à partir des valeurs de deux listes. Au lieu de les saisir un par un, vous pouvez utiliser les compréhensions de dictionnaire (

dictionnaire

compréhension), qui est une manière élégante et concise de créer un dictionnaire Cela fonctionne exactement comme les compréhensions de liste, sauf que la différence est - quand ! en créant une compréhension de liste, vous placez tout entre crochets, comme [], alors que dans une compréhension de dictionnaire, vous enveloppez tout entre accolades, comme {}.

Supposons qu'il y ait deux listes - champs et détails - comme indiqué ci-dessous.

fields = [‘name’, ‘country’, ‘age’, ‘gender’]
 details = [‘pablo’, ‘Mexico’, 30, ‘Male’]

Un moyen simple est d'utiliser une compréhension de dictionnaire comme celle-ci -

new_dict = {key: value for key, value in zip(fields, details)}
 
 # Output
 {'name': 'pablo', 'country': 'Mexico', 'age': 30, 'gender': 'Male'}

La chose importante à comprendre ici est comment fonctionne la fonction zip.

En Python, la fonction zip accepte des objets itérables tels que des chaînes, des listes ou des dictionnaires en entrée et les renvoie agrégés en tuples.

Donc, dans ce cas, zip a formé une paire de chaque élément à partir des champs de liste et des détails. Lorsque vous utilisez key:value dans une compréhension de dictionnaire, décompressez simplement ce tuple en paires clé-valeur individuelles.

Lorsque vous utilisez le constructeur dict() intégré à Python (pour créer des dictionnaires), le processus devient encore plus rapide, puisque dict() est au moins 1,3 fois plus rapide que la compréhension de dictionnaires

 !

Nous devons donc utiliser ce constructeur avec la fonction zip(), qui a une syntaxe beaucoup plus simple - dict(zip(fields, details))

Résumé

Comme je l'ai mentionné au début, Python est très flexible, car il existe plusieurs façons d’obtenir le même résultat. En fonction de la complexité de la tâche, vous devez choisir la meilleure façon de l'accomplir.

J'espère que cet article vous sera utile. S'il existe un autre moyen de faire la même chose que celle mentionnée dans cet article, faites-le-moi savoir.

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!