5 fonctionnalités Python que je ne connaissais pas - mais en vain

Python peut sans aucun doute être appelé un langage qui a connu une croissance importante au cours de la dernière décennie, un langage qui s'est avéré puissant. J'ai créé de nombreuses applications Python, des cartes interactives aux blockchains . Python a une tonne de fonctionnalités. Il est très difficile pour les débutants de saisir tout cela à la fois.



Même si vous êtes un programmeur qui passe à Python à partir d'un autre langage comme C, ou si vous êtes un scientifique qui travaillait dans MATLAB, la programmation Python utilisant des abstractions de haut niveau est certainement une expérience très spéciale. Je veux parler de cinq très importantes, à mon avis, des fonctionnalités Python que, malheureusement, je ne connaissais pas auparavant.

1. Inclusion de liste - écriture d'un code compact


Beaucoup appellent des mécanismes Python tels que lambda , map et filter les secrets mêmes que chaque programmeur novice devrait apprendre. Et même si je suis sûr que tout cela vaut la peine d'être connu, dans la plupart des situations dans lesquelles ces outils peuvent être appliqués, j'ai rencontré une flexibilité insuffisante de ces outils. En conséquence, ils sont loin d'être aussi utiles qu'ils le paraissent.

Lambda est une méthode de création de petites fonctions unifilaires à usage unique. Si une fonction est appelée plusieurs fois, elle dégrade les performances. Mais en même temps, la fonction map applique la fonction à tous les éléments de la liste, et le filter sélectionne parmi un certain ensemble d'éléments un sous-ensemble correspondant à la condition spécifiée par l'utilisateur.

 add_func = lambda z: z ** 2 is_odd = lambda z: z%2 == 1 multiply = lambda x,y: x*y aList = list(range(10)) print(aList) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 

L'inclusion de liste (compréhension de liste) est une conception compacte et pratique utilisée pour créer des listes à partir d'autres listes à l'aide d'expressions et de conditions flexibles. Cette construction est décrite à l'aide de crochets. Ils incluent des expressions ou des fonctions qui s'appliquent à chaque élément de la liste uniquement si cet élément remplit une certaine condition. L'inclusion de liste peut être une structure à plusieurs niveaux contenant des blocs imbriqués. Cela vous permet de traiter des listes imbriquées, offrant beaucoup plus de flexibilité que l'utilisation de la map et du filter .

Voici la syntaxe pour l'inclusion de liste:

 [ expression(x) for x in aList if optional_condition(x) ] 

Voici un exemple:

 print(list(map(add_func, aList))) print([x ** 2 for x in aList]) # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] print(list(filter(is_odd, aList))) print([x for x in aList if x%2 == 1]) # [1, 3, 5, 7, 9] # [1, 3, 5, 7, 9] 

2. Travailler avec des listes - listes circulaires


Python vous permet d'utiliser des index négatifs lorsque vous travaillez avec des listes. La comparaison suivante est vraie:

 aList[-1] == aList[len(aList)-1] 

Cela permet, par exemple, d'obtenir le deuxième élément de la fin de la liste en utilisant la construction aList[-2] . D'autres conceptions similaires sont possibles.

De plus, vous pouvez obtenir une tranche de la liste:

 aList[start:end:step] 

Ici, l'élément initial de la liste est inclus dans la tranche résultante et l'élément final n'y est pas inclus. Supposons que la liste ressemble à ceci:

 aList = [1, 2, 3, 4, 5, 6, 7, 8, 9] 

La aList[2:5] ressemblera à [2, 3, 4] . De plus, vous pouvez "retourner" la liste à l'aide de la commande aList[::-1] . Dans notre cas, cela donnera [9, 8, 7, 6, 5, 4, 3, 2, 1] . Je trouve cette solution à la tâche «flip» de la liste très visuelle et réussie.

Vous pouvez également décompresser la liste en plaçant les valeurs qui y sont stockées dans des variables distinctes. Ou - «décomposer» ses valeurs dans des variables distinctes et de nouvelles listes à l'aide d'un astérisque:

 a, b, c, d = aList[0:4] print(f'a = {a}, b = {b}, c = {c}, d = {d}') # a = 0, b = 1, c = 2, d = 3 a, *b, c, d = aList print(f'a = {a}, b = {b}, c = {c}, d = {d}') # a = 0, b = [1, 2, 3, 4, 5, 6, 7], c = 8, d = 9 

3. fonctions zip et énumération - création de boucles puissantes


La fonction zip crée un itérateur qui combine les éléments de plusieurs listes. Cela permet une analyse parallèle des listes dans les boucles et un tri parallèle. Vous pouvez ramener les éléments combinés à leur état normal à l'aide de l'opérateur * .

Voici un exemple de travail avec la fonction zip :

 numList = [0, 1, 2] engList = ['zero', 'one', 'two'] espList = ['cero', 'uno', 'dos'] print(list(zip(numList, engList, espList))) # [(0, 'zero', 'cero'), (1, 'one', 'uno'), (2, 'two', 'dos')] for num, eng, esp in zip(numList, engList, espList):    print(f'{num} is {eng} in English and {esp} in Spanish.') # 0 is zero in English and cero in Spanish. # 1 is one in English and uno in Spanish. # 2 is two in English and dos in Spanish. 

Mais voici comment remettre les listes à leur état normal:

 Eng = list(zip(engList, espList, numList)) Eng.sort() #   engList a, b, c = zip(*Eng) print(a) print(b) print(c) # ('one', 'two', 'zero') # ('uno', 'dos', 'cero') # (1, 2, 0) 

La fonction enumerate , à première vue, peut sembler très compliquée, mais si vous la traitez, il s'avère qu'elle peut être utile dans de nombreux cas. Il s'agit d'un compteur automatique qui est souvent utilisé for boucles. De plus, dans de tels cycles, il n'est pas nécessaire de créer et d'incrémenter une variable de compteur en utilisant des constructions telles que counter = 0 et counter += 1 .

Les fonctions zip et enumerate sont deux des outils les plus puissants utilisés dans la construction for boucles:

 upperCase = ['A', 'B', 'C', 'D', 'E', 'F'] lowerCase = ['a', 'b', 'c', 'd', 'e', 'f'] for i, (upper, lower) in enumerate(zip(upperCase, lowerCase), 1):    print(f'{i}: {upper} and {lower}.') # 1: A and a. # 2: B and b. # 3: C and c. # 4: D and d. # 5: E and e. # 6: F and f. 

4. Générateurs - utilisation efficace de la mémoire


Les générateurs sont utilisés dans les cas où il est nécessaire d'effectuer certains calculs qui conduisent à l'apparition d'un grand ensemble de résultats, mais en même temps, il est nécessaire d'éviter l'allocation simultanée de mémoire pour stocker tous ces résultats. En d'autres termes, les générateurs émettent certaines valeurs, comme on dit, «à la volée». Cependant, ils ne stockent pas en mémoire les valeurs précédemment trouvées par eux. En conséquence, la mémoire est utilisée avec parcimonie.

Les générateurs sont souvent utilisés pour lire des fichiers volumineux ou pour créer des séquences infinies à l'aide du mot clé yield . Je trouve souvent approprié de les utiliser dans mes projets de recherche.

 def gen(n):  #     ,   >= n    while True:        yield n        n += 1       G = gen(3)   #   3 print(next(G)) # 3 print(next(G)) # 4 print(next(G)) # 5 print(next(G)) # 6 

5. Environnement virtuel - isolation du code


Si vous ne pouviez choisir qu'une seule idée de cet article dont vous vous souveniez, alors je vous conseillerais de celle dont nous parlerons dans cette section. Nous parlons d'environnements virtuels (environnement virtuel).

Les applications Python utilisent souvent de nombreux packages différents. Ils ont été créés par différents développeurs, ils diffèrent par des ensembles complexes de dépendances. Dans une certaine application, une version spécifique d'une certaine bibliothèque peut être utilisée. Cependant, une autre version pour une telle application ne fonctionnera pas. Mais que faire si plusieurs applications utilisent des versions différentes de la même bibliothèque? C'est une question difficile qui nous amène à l'idée qu'il n'y a pas d'environnement universel, dont les packages installés conviennent à absolument toutes les applications. La réponse à cette question peut être appelée l'utilisation d'environnements virtuels.

Pour créer des environnements virtuels isolés les uns des autres, vous pouvez procéder comme suit:

 conda create -n venv pip python=3.7 #   python source activate venv ... source deactivate 

Résumé


Dans cet article, nous avons couvert 5 fonctionnalités Python utiles. À savoir, il s'agissait d'inclusions de listes, de listes cycliques, de fonctions zip et d' enumerate , de générateurs et d'environnements virtuels. Nous espérons que ces fonctionnalités vous seront utiles.

Chers lecteurs! Si vous pouviez dire à un programmeur novice une seule fonctionnalité Python, que choisiriez-vous?

Source: https://habr.com/ru/post/fr482458/


All Articles