16 Python One-Liners utiles pour simplifier les tâches courantes
Vous souhaitez écrire du code Python à la fois épuré et conforme aux standards du langage ? Voici une sélection de lignes de code Python, concises et pratiques, parfaites pour des opérations courantes.
Les programmeurs novices en Python consacrent souvent du temps à maîtriser les structures de données fondamentales, telles que les listes et les chaînes de caractères. Certaines manipulations sur ces structures peuvent être réalisées en utilisant des extraits de code d'une seule ligne, à la fois clairs et efficaces.
Bien que la priorité du programmeur soit la lisibilité et la maintenance du code, plutôt que sa brièveté à tout prix, Python offre la possibilité de créer des lignes de code simples qui respectent les bonnes pratiques de programmation.
Cet article explore des lignes de code uniques pour des opérations courantes sur des listes et des chaînes de caractères en Python.
C’est parti !
Création d'une liste de nombres
La méthode la plus simple pour obtenir une liste de nombres est d'utiliser la fonction `range()`. Cette fonction génère un objet de type `range` qui peut être converti en liste. Par exemple, `range(num)` produira la séquence 0, 1, 2,.., num-1.
>>> nombres = list(range(10)) >>> nombres [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Approfondissez votre connaissance de la fonction `range()`.
Il est également possible d'utiliser `range()` avec un pas optionnel. `range(début, fin, pas)` générera une séquence commençant à `début`, puis `début + pas`, `début + 2*pas`, et ainsi de suite. La dernière valeur sera `début + k*pas` telle que `(début + k*pas) < fin` et `(début + (k+1)*pas) > fin`.
Déterminer les valeurs maximale et minimale d'une liste
Les fonctions natives `max()` et `min()` permettent de trouver respectivement le plus grand et le plus petit élément d'une liste.
>>> min_valeur, max_valeur = min(nombres), max(nombres) >>> min_valeur 0 >>> max_valeur 9
📑 Remarque sur les affectations multiples
Notez que nous avons assigné les valeurs à `min_valeur` et `max_valeur` en une seule opération. Python supporte cette forme d'affectation multiple, très pratique pour décompresser des itérables et attribuer des valeurs à plusieurs variables simultanément.
Éliminer les doublons d'une liste
Une autre opération fréquente est la suppression des doublons dans les listes Python. C'est indispensable lorsque vous travaillez uniquement avec des valeurs uniques. La façon la plus directe de réaliser cela est de transformer la liste en un ensemble.
Un ensemble est une structure de données native dont tous les éléments sont uniques et hachables.
>>> nombres1 = [2,4,7,9,7,10]
Dans `nombres1`, l'élément 7 apparaît deux fois. Le convertir en ensemble supprimera ce doublon, ne laissant que les valeurs uniques.
Puisque nous avons besoin de travailler avec une liste, nous reconvertissons l'ensemble en liste. Cette opération s'effectue en une ligne de code :
>>> nombres1 = list(set(nombres1)) >>> nombres1 [2, 4, 7, 9, 10]
📒 Pour plus de méthodes pour éliminer les doublons d'une liste Python, consultez ce guide.
Compter les occurrences dans une liste
Pour savoir combien de fois un élément figure dans une liste, utilisez la méthode native `count()`. `liste.count(elt)` retourne le nombre de fois que `elt` apparaît dans `liste`.
>>> nombres [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Ici, le nombre 7 apparaît une seule fois dans la liste `nombres`, donc la méthode `count()` renvoie 1.
>>> nombres.count(7) 1
Vérifier si tous les éléments d'une liste satisfont une condition
Pour vérifier si tous les éléments d'une liste remplissent une condition donnée, utilisez la fonction intégrée `all()` de Python.
La fonction `all()` prend un itérable en argument et renvoie `True` si tous les éléments de l'itérable sont évalués à `True` (ou considérés comme vrais).
Dans l'exemple suivant, nous vérifions si tous les éléments de la liste `nombres2` sont impairs.
>>> nombres2 = [3,4,7,11,21,67,12]
Nous utilisons une compréhension de liste pour construire une liste de booléens, que nous passons ensuite en argument à `all()`.
Ici, `num%2!=0` sera `False` pour les éléments 4 et 12, qui sont pairs. Par conséquent, la liste de booléens contient `False` et `all(liste)` retourne `False`.
>>> all([num%2!=0 for num in nombres2]) False
💡 Il est important de savoir que `all([])` (c'est-à-dire `all()` avec un itérable vide) renvoie `True`.
Vérifier si un élément d'une liste satisfait une condition
Pour vérifier si au moins un élément d'une liste répond à un critère donné, utilisez la fonction `any()`. `any(liste)` renvoie `True` si au moins un élément est évalué à `True`.
>>> nombres2 = [3,4,7,11,21,67,12]
Comme dans l'exemple précédent, nous utilisons une compréhension de liste pour obtenir une liste de booléens. La liste `nombres2` contient des nombres pairs. La fonction `any()` renvoie donc `True`.
>>> any([num%2 for num in nombres2]) True
Inverser une chaîne de caractères
En Python, les chaînes de caractères sont immuables. Pour inverser une chaîne, vous ne pouvez donc obtenir qu'une copie inversée. Il existe deux méthodes courantes, toutes deux exprimables en une seule ligne de code Python : utiliser le découpage de chaîne ou des fonctions intégrées.
Utilisation du découpage de chaîne
Le découpage de chaîne avec un pas négatif renvoie une portion de la chaîne en commençant par la fin. La syntaxe est `chaîne[début:fin:pas]`. Que se passe-t-il si le pas est de -1 et les indices de début et de fin sont omis ?
Cela renvoie une copie de la chaîne, en partant de la fin, en incluant chaque caractère.
>>> chaine1[::-1] 'olleh'
Utilisation de la fonction `reversed()`
La fonction intégrée `reversed()` retourne un itérateur inversé sur une séquence.
>>> reversed(chaine1) <reversed object at 0x008BAF70> >>> for carac in chaine1: ... print(carac) ... h e l l o
Vous pouvez l'utiliser conjointement avec la méthode `join()`, comme suit :
>>> ''.join(reversed(chaine1)) 'olleh'
Transformer une chaîne en liste de caractères
Imaginons que nous souhaitions diviser une chaîne de caractères en une liste de caractères. Cela est possible avec une compréhension de liste.
>>> chaine1 = 'hello'
Les compréhensions de liste sont parmi les outils les plus puissants de Python, condensés en une seule ligne.
📒 Approfondissez vos connaissances sur les compréhensions de liste en Python.
Nous parcourons la chaîne et collectons chaque caractère.
>>> caracs = [carac for carac in chaine1] >>> caracs ['h', 'e', 'l', 'l', 'o']
Pour séparer une chaîne en une liste de chaînes à chaque espace, utilisez la méthode `split()`.
>>> chaine2 = 'hello world' >>> chaine2.split() ['hello', 'world']
Nous avons déjà vu comment utiliser les compréhensions de liste pour transformer une chaîne en liste de caractères. Dans cet exemple, nous collectons chaque caractère en parcourant la chaîne.
Nous voulons maintenant parcourir la chaîne et ne récupérer que les chiffres. Comment faire ?
- Nous pouvons insérer une condition de filtrage dans la compréhension de liste en utilisant la méthode `isdigit()`.
- `c.isdigit()` renvoie `True` si `c` est un chiffre et `False` sinon.
>>> chaine3 = 'python3' >>> chiffres = [c for c in chaine3 if c.isdigit()] >>> chiffres ['3']
Vérifier si une chaîne commence par une sous-chaîne spécifique
Pour vérifier si une chaîne débute par une sous-chaîne précise, utilisez la méthode `startswith()`. `chaine1.startswith(sous_chaine)` retourne `True` si `chaine1` commence par `sous_chaine`. Sinon, il retourne `False`.
Voici quelques exemples :
>>> chaine4 = 'coding'
>>> chaine4.startswith('co')
True
>>> chaine5 = 'python'
>>> chaine5.startswith('co')
False
Vérifier si une chaîne finit par une sous-chaîne spécifique
Comme vous l'avez peut-être deviné, vous pouvez utiliser la méthode `endswith()` pour vérifier si une chaîne se termine par une sous-chaîne donnée.
>>> chaine5 = 'python'
>>> chaine5.endswith('on')
True
Il est également possible d'utiliser cette méthode dans une compréhension de liste afin d'obtenir une liste de booléens indiquant si chaque chaîne d'une liste se termine ou non par la sous-chaîne donnée.
>>> chaines = ['python','neon','nano','silicon']
>>> fin_avec = [chaine.endswith('on') for chaine in chaines]
>>> fin_avec
[True, True, False, True]
Rassembler les éléments d'une liste en une chaîne
Nous avons vu comment diviser une chaîne en liste de caractères. Comment faire l'opération inverse, c'est-à-dire combiner les éléments d'une liste en une seule chaîne ?
Pour cela, utilisez la méthode `join()` de la chaîne avec la syntaxe : `separateur.join(liste)`.
Nous ne souhaitons que combiner les éléments d'une liste en une seule chaîne, sans séparateur. On définit donc le séparateur sur une chaîne vide.
>>> liste_1 = ['p','y','t','h','o','n','3'] >>> ''.join(liste_1) 'python3'
Créer un dictionnaire Python
De la même manière que les compréhensions de liste nous permettent de créer des listes à partir d'itérables existants, les compréhensions de dictionnaire permettent de générer de nouveaux dictionnaires à partir d'itérables.
Les compréhensions de dictionnaire Python sont des constructions efficaces qui peuvent nous aider à construire des dictionnaires à la volée.
Voici une liste de noms, sous forme de chaînes de caractères :
>>> noms = ['Joe','Amy','Jake','Florence']
Nous créons `noms_d`, un dictionnaire associant les noms (chaînes de caractères) à la longueur de chaque nom.
>>> noms_d = {nom:len(nom) for nom in noms}
>>> noms_d
{'Joe': 3, 'Amy': 3, 'Jake': 4, 'Florence': 8}
Attribuer conditionnellement des valeurs aux variables
Il est parfois nécessaire d'attribuer des valeurs à des variables en fonction d'une condition spécifique.
Par exemple, si vous demandez l'âge d'une personne, vous pouvez décider, en fonction de cet âge, si elle est autorisée à participer à un événement.
Pour réaliser cette affectation conditionnelle en Python, utilisez l'opérateur ternaire, en une seule ligne de code.
>>> age = 21 >>> autorisé = True if age >= 18 else False >>> autorisé True
🔖 En savoir plus sur l'opérateur ternaire en Python.
Générer toutes les permutations
Une permutation désigne un agencement possible des éléments d'un ensemble. Pour un ensemble de n éléments uniques, il existe n ! manières de les agencer, donc n ! permutations.
Prenons la liste de lettres suivante :
>>> lettres = ['a','b','c']
Vous pouvez utiliser les permutations du module `itertools` pour créer toutes les permutations possibles d'un itérable donné.
>>> lettres_p = permutations(lettres) >>> lettres_p <itertools.permutations object at 0x0127AF50>
Comme vous le voyez, `permutations(iterable)` renvoie un objet de permutation que l'on peut parcourir à l'aide d'une boucle `for` :
>>> for p in lettres_p:
... print(p)
...
('a', 'b', 'c')
('a', 'c', 'b')
('b', 'a', 'c')
('b', 'c', 'a')
('c', 'a', 'b')
('c', 'b', 'a')
Il est possible de réécrire ceci sous forme d'une expression unique, en transformant l'objet de permutation en une liste :
>>> lettres_p = list(permutations(lettres))
>>> lettres_p
[('a', 'b', 'c'), ('a', 'c', 'b'), ('b', 'a', 'c'), ('b', 'c', 'a'), ('c', 'a', 'b'), ('c', 'b', 'a')]
Ici, il y a trois éléments uniques et donc 3! = 6 permutations possibles.
Générer des sous-ensembles d'une liste
Il peut être nécessaire de créer tous les sous-ensembles possibles d'une taille donnée à partir d'une liste ou d'un autre itérable. Prenons la liste de lettres et créons toutes les sous-listes de taille 2.
Pour cela, utilisons les combinaisons du module `itertools` :
>>> from itertools import combinations
>>> lettres_2 = list(combinations(lettres,2))
>>> lettres_2
[('a', 'b'), ('a', 'c'), ('b', 'c')]
Conclusion
Dans ce tutoriel, nous avons examiné des lignes de code Python très utiles pour réaliser des opérations courantes sur des listes et des chaînes de caractères. Nous avons aussi appris à utiliser des constructions Python comme les compréhensions de listes et de dictionnaires, et comment les combiner avec des fonctions natives pour accomplir les tâches souhaitées.
Pour aller plus loin, vous pouvez consulter cette sélection de projets Python adaptés aux débutants.