Une petite antisèche sur les syntaxes python

Je maintiens depuis quelque temps déjà une liste de syntaxe que j’utilise régulièrement pour les avoir facilement sous la main. Aujourd’hui, je partage donc avec vous cette liste qui sera mise à jour le plus régulièrement possible.

Pour rendre cette énumération plus pratique, voici les différentes sous-sections:

LES ITÉRABLES

Un itérable est ce qui accepte l’itération, ce sur quoi on peut itérer, c’est à dire une collection dont on peut prendre les éléments un à un.

Sam & Max

Création d’un itérable

On génère une séquence allant de 1 à 50 avec un incrément de 3 et on affiche le résultat :

x = range(1,50, 3)
list(x)
Output :
[1, 4, 7, 10, 13, 16, 19, 22, 25, 28, 31, 34, 37, 40, 43, 46, 49]

Calcul de la somme des éléments de l’itérable

On fait la somme de nos éléments contenus dans notre itérable x

sum(x)
Output :
425

Appliquer un filtre

Le filtre sur notre itérable nous retourne les nombres pairs

x_filtered = filter(lambda i: i % 2==0, x)
list(x_filtered)
Output :
[4, 10, 16, 22, 28, 34, 40, 46]

Trouver si au moins un élément de l’itérable est pair

any(i % 2==0 for i in x)
Output :
True

Trouver si tous les éléments de l’itérable sont pairs

all(i % 2==0 for i in x)
Output :
False

Appliquer une fonction « Numpy »

Calcul de la somme cumulée des éléments de notre itérable

import numpy as np
list(np.cumsum(x))
Output :
[1, 5, 12, 22, 35, 51, 70, 92, 117, 145, 176, 210, 247, 287, 330, 376, 425]

Renvoyer le tuple (index, valeur) de l’itérable

t = list(enumerate(x))
t
Output :
 (3, 10),
 (4, 13),
 (5, 16),
 (6, 19),
 (7, 22),
 (8, 25),
 (9, 28),
 (10, 31),
 (11, 34),
 (12, 37),
 (13, 40),
 (14, 43),
 (15, 46),
 (16, 49)]

Pivoter la liste de tuples

list(zip(*t))
Output :
[(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16),
 (1, 4, 7, 10, 13, 16, 19, 22, 25, 28, 31, 34, 37, 40, 43, 46, 49)]

Transformer un itérable en liste

s = "Le Machine Learning est quelque chose de nouveau sous le soleil : une technologie qui se construit elle-même."

l = s.split(' ')
l
Output :
['Le',
 'Machine',
 'Learning',
 'est',
 'quelque',
 'chose',
 'de',
 'nouveau',
 'sous',
 'le',
 'soleil',
 ':',
 'une',
 'technologie',
 'qui',
 'se',
 'construit',
 'elle-même.']

Transformer un itérable en chaine de caractères

'_'.join(l)
Output :
'Le_Machine_Learning_est_quelque_chose_de_nouveau_sous_le_soleil_:_une_technologie_qui_se_construit_elle-même.'

Trier un itérable

On applique la fonction str.lower pour ne pas prendre en compte la casse.

ol = sorted(l, key=str.lower)
ol
Output :
[':',
 'chose',
 'construit',
 'de',
 'elle-même.',
 'est',
 'Le',
 'le',
 'Learning',
 'Machine',
 'nouveau',
 'quelque',
 'qui',
 'se',
 'soleil',
 'sous',
 'technologie',
 'une']

Si l’on souhaite avoir l’index de notre chaine de caractère associer à notre sous-chaine de caractère, nous pouvons utiliser la fonction enumarate() :

sorted(enumerate(l), key=lambda i: i[1].lower())
Output :
[(11, ':'),
 (5, 'chose'),
 (16, 'construit'),
 (6, 'de'),
 (17, 'elle-même.'),
 (3, 'est'),
 (0, 'Le'),
 (9, 'le'),
 (2, 'Learning'),
 (1, 'Machine'),
 (7, 'nouveau'),
 (4, 'quelque'),
 (14, 'qui'),
 (15, 'se'),
 (10, 'soleil'),
 (8, 'sous'),
 (13, 'technologie'),
 (12, 'une')]

Utiliser l’opérateur *

Pour générer un itérable avec un même élément répété 10 fois

[1] * 10
Output :
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1]

Facilement créer un diviseur :

'-' * 20
Output :
'--------------------'

Convertir une liste de tuples en dictionnaire

dict(enumerate(l))
Output :
{0: 'Le',
 1: 'Machine',
 2: 'Learning',
 3: 'est',
 4: 'quelque',
 5: 'chose',
 6: 'de',
 7: 'nouveau',
 8: 'sous',
 9: 'le',
 10: 'soleil',
 11: ':',
 12: 'une',
 13: 'technologie',
 14: 'qui',
 15: 'se',
 16: 'construit',
 17: 'elle-même.'}

Fusionner deux dictionnaires

On créé trois dictionnaires : les deux premier que l’on souhaite fusionner et une dernière qui va contenir la fusion des deux dictionnaire. Ce dernier est initialisé comme une copie de notre premier dict avec la méthode .copy()

d1 = {"Arthur":1, "John":1}
d1_d2 = d1.copy()

d2 = {"Jason":2, "Kevin":5, "John":33}

Enfin, on utilise la méthode .update() pour fusionner nos deux dictionnaires

d1_d2.update(d2)
d1_d2
Output :
{'Arthur': 1, 'John': 33, 'Jason': 2, 'Kevin': 5}

Autre syntaxe possible :

{**d1 , **d2}
Output :
{'Arthur': 1, 'John': 33, 'Jason': 2, 'Kevin': 5}

NB: Si des clés sont présentes dans les deux dictionnaires, c’est la valeur contenue dans le second dictionnaire qui sera conservée

Avec une addition des valeurs pour les clés identiques

Pour cela on peut importer Counter

from collections import Counter

dc1 = Counter(d1)
dc2 = Counter(d2)
dict(dc1 + dc2)
Output :
{'Arthur': 1, 'John': 34, 'Jason': 2, 'Kevin': 5}

Compter les occurrences des éléments d’un itérable

dict(Counter(['jaune', 'vert', 'vert']))
Output :
{'jaune': 1, 'vert': 2}

Autre exemple avec une chaine de caractère :

dict(Counter('Arthur'))
Output :
{'A': 1, 'r': 2, 't': 1, 'h': 1, 'u': 1}

Stocker les intervalles (slice)

Si on veut avoir une variable qui nous permet de récupérer le dernier élément d’un itérable, il nous suffit d’utiliser la fonction slice()

l = ['Le', 'Machine', 'Learning', 'est', 'quelque', 'chose', 'de', 'nouveau', 'sous', 'le', 'soleil', ':', 'une', 'technologie', 'qui', 'se', 'construit', 'elle-même.']

LAST_ELEMENT = slice(-1, None)
l[LAST_ELEMENT]
Output :
['elle-même.']

Se débarasser de caractères avant et après d’une chaine de caractères

text_balise = "[b]Ceci est un texte en gras[/b]"

left_strip = text_balise.lstrip('[/b]')
right_strip = text_balise.rstrip('[/b]')
text_strip = text_balise.strip('[/b]')

print(left_strip)
print(right_strip)
print(text_strip)
Output :
'Ceci est un texte en gras[/b]'
'[b]Ceci est un texte en gras'
'Ceci est un texte en gras'

Inverser l’ordre d’un itérable

text_strip[::-1]
Output :
'sarg ne etxet nu tse iceC'

Retourner toutes les permutations possibles

from itertools import permutations

perm = permutations([1, 2, 3])
list(perm)
Output :
[(1, 2, 3), (1, 3, 2), (2, 1, 3), (2, 3, 1), (3, 1, 2), (3, 2, 1)]

Retourner toutes les combinaisons possibles

from itertools import combinations 

comb = combinations([1, 2, 3, 4, 5], 3)
list(comb)
Output :
[(1, 2, 3),
 (1, 2, 4),
 (1, 2, 5),
 (1, 3, 4),
 (1, 3, 5),
 (1, 4, 5),
 (2, 3, 4),
 (2, 3, 5),
 (2, 4, 5),
 (3, 4, 5)]

L’UNPACKING

Affectation d’éléments d’un itérable à des variables

a, b, c = [2, 5, 10]
a
Output :
2

Affectation partielle d’éléments d’un itérable à des variables

a, *b = [2, 5, 10]

print(a)
print(b)
Output :
2
[5, 10]

Interchanger les valeurs des variables

a, b = b, a
a
Output :
[5, 10]

LES COMPRÉHENSIONS

Utilisation des compréhensions de liste

Si on souhaite ajouter 3 à chaque élément de d’un itérable :

x = [1, 4, 7, 10, 13, 16, 19, 22, 25, 28, 31, 34, 37, 40, 43, 46, 49]

z = [i + 3 for i in x]
z
Output :
[4, 7, 10, 13, 16, 19, 22, 25, 28, 31, 34, 37, 40, 43, 46, 49, 52]

Utilisation des compréhensions de dictionnaire

Si on souhaite créer un dictionnaire de mapping entre un nombre et son carré :

x = [1, 4, 7, 10, 13, 16, 19, 22, 25, 28, 31, 34, 37, 40, 43, 46, 49]

{i:i ** 2 for i in x}
Output :
{1: 1,
 4: 16,
 7: 49,
 10: 100,
 13: 169,
 16: 256,
 19: 361,
 22: 484,
 25: 625,
 28: 784,
 31: 961,
 34: 1156,
 37: 1369,
 40: 1600,
 43: 1849,
 46: 2116,
 49: 2401}