Xavier Lamorlette

Python : éléments de programmation fonctionnelle

Fonctions

all, any

 
return any(value != 0 for value in sequence)

filter

 
list(filter(lambda item: [condition → bool], items_list))

map

map applique une fonction aux éléments, en renvoyant un itérable.

Extraire une liste d'entiers à partir d'une chaine de caractères :

list(map(int, string_to_parse.split()))

Convertir une liste de chaines de caractères en liste de listes de caractères :

list(map(list, ["toto", "tata"]))

reduce (dans functools)

Applique cumulativement une fonction aux éléments, de gauche à droite, en renvoyant une valeur.

reduce(lambda x, y: x + y, [1, 2, 3, 4, 5])
→ ((((1 + 2) + 3) + 4) + 5)

sum, prod (dans math)

Additionne et multiplie les éléments, en renvoyant une valeur.

zip

zip est un itérateur qui aggrège les éléments d'itérables en tuples :

zip("abc", [1, 2, 3])
→ ("a", 1), ("b", 2), ("c", 3)

Pour faire l'inverse :

unzip = lambda liste: [list(li) for li in zip(*liste)]
unzip([(1, 2), (3, 4), (5, 6)])
→ [[1, 3, 5], [2, 4, 6]]

Expressions rationnelles : module re

re.findall

Trouve toutes les correspondances successives (qui ne se chevauchent pas), et renvoie une liste de strings ou de tuples.

re.findall(r'(\w+)=(\d+)', 'set width=20 and height=10')
→ ('width', '20'), ('height', '10')

re.finditer

Comme findall mais renvoie un itérateur.

Module bisect

Implémente l'algorithme de recherche dichotomique dans une liste triée.
Notamment, bisect_left() permet de trouver le point d'insertion d'un élément (i.e. la position du premier élément ≥).

Module collections

Counter

Équivalent du multi-set : dictionnaire comptant les occurrences d'éléments.

number_per_item = Counter(items_list)
reverse_cardinals = sorted(list(number_per_item.values()), reverse=True)

defaultdict

Dictionnaire avec un initialiseur appelé pour tout premier accès à un élément.

items_list = [('yellow', 1), ('blue', 2), ('yellow', 3), ('blue', 4), ('red', 1)]
numbers_per_colour = defaultdict(list)
for key, value in items_list:
    numbers_per_colour[key].append(value)
→ [('blue', [2, 4]), ('red', [1]), ('yellow', [1, 3])]

deque

Une “deque” est une “double-ended queue” qui permet d'ajouter et d'enlever des éléments des deux côtés de la queue en temps constant.

OrderedDict

Dictionnaire ordonné, avec une méthode pour déplacer un item à la fin.

Module heapq

Les fonctions de ce module permettent d'implémenter une queue priorisée (“heap queue” ou “priority queue”).
Une heap (« tas ») est un arbre binaire dans lequel chaque parent contient une valeur inférieure ou égale à celles de tous ses enfants.
La structure de données de la heap est une liste d'éléments (par exemples des paires dont le premier élément est la priorité).

propagation_heap = [(0, "toto")]
while propagation_heap:
    priority, element = heappop(propagation_heap)
    …
    heappush(propagation_heap, (next_priority, next_element))

Module itertools

groupby

groupby regroupe les valeurs consécutives :

(key, list(group)) for key, group in groupby('aaabbcaa')
→ ('a', ['a', 'a', 'a']), ('b', ['b', 'b']), ('c', ['c']), ('a', ['a', 'a'])

list(group) for key, group in groupby('abc de fgh', lambda item: item == " ") if not key
→ ['a', 'b', 'c'], ['d', 'e'], ['f', 'g', 'h']

pairwise

Renvoie les paires successives d'un itérable.

pairwise("abcd")
→ ('a', 'b') ('b', 'c') ('c', 'd')

product

Produit cartésien d'itérables.

product(A, B)
↔ ((x, y) for x in A for y in B)

Pour obtenir le produit d'un itérable avec lui-même, on peut utiliser repeat :

product(range(2), repeat=3)
→ 000 001 010 011 100 101 110 111

La dernière mise à jour de cette page date de mai 2024.

Le contenu de ce site est, en tant qu'œuvre originale de l'esprit, protégé par le droit d'auteur.
Pour tout commentaire, vous pouvez m'écrire à xavier.lamorlette@gmail.com.