30 astuces Python pour améliorer votre code, accompagnées d'exemples

Les compétences en codage Python sont de plus en plus recherchées ces dernières années. Afin de vous aider à développer vos compétences en programmation Python, nous avons sélectionné 30 astuces Python intéressantes que vous pouvez utiliser pour améliorer votre code. Essayez d'en apprendre une chaque jour pendant les 30 prochains jours et consultez notre article sur les meilleures pratiques Python pour vous assurer que votre code est de la plus haute qualité. 

Si vos compétences en Python ne sont pas encore tout à fait au point, vous pouvez également les perfectionner grâce à notre cursus Python Skill Track.

#1 Tranchage

a = "Hello World!"
print(a[::-1])

"""
!dlroW olleH
"""

Le découpage est une fonctionnalité de Python qui repose sur l'indexation pour permettre aux utilisateurs d'accéder à un sous-ensemble d'une séquence. Un index est simplement la position d'un élément dans une séquence. Si le type de séquence est modifiable, vous pouvez utiliser le découpage pour extraire et modifier des données. 

Remarque: Nous pouvons également utiliser le découpage sur une séquence immuable, mais toute tentative de modification du segment entraînera une erreur TypeError. 

Le format dans lequel les tranches sont implémentées est : séquence[début:fin:pas]. Si aucune valeur n'est spécifiée dans les paramètres start, stop et step, la séquence utilisera les valeurs par défaut. Les valeurs par défaut sont les suivantes : 

• La valeur par défaut de « start » est 0. 
• « stop » correspond par défaut à la longueur de la séquence.
• La valeur par défaut de « step » est 1 si elle n'est pas spécifiée. 

Lorsque la séquence [début : fin] est fournie, les éléments renvoyés vont de l'index de départ jusqu'à la fin - 1(l'index de fin n'est pas inclus). 

Nous pouvons également transmettre des indices négatifs, qui peuvent être utilisés pour inverser la séquence. Par exemple, dans une liste de 4 éléments, l'index 0 correspond également à l'index -4, et le dernier index correspond également à -1. Dans l'exemple de code ci-dessus, cette connaissance a été appliquée au paramètre step de la séquence. Par conséquent, la chaîne a été imprimée à l'envers, en commençant par la fin de la séquence jusqu'à l'index 0.   

#2 Échange sur place / Affectation simultanée

a = 10
b = 5
print(f"First: {a, b}")

"""
First: (10, 5)
"""

a, b = b, a + 2
print(f"Second: {a, b}")

"""
Second: (5, 12)
"""

Si votre première impression était que la valeur de b serait 7 au lieu de 12, vous êtes tombé dans le piège de l'échange sur place. 

En Python, il est possible de décompresser des itérables vers des variables en une seule affectation grâce à la décompression automatique. Par exemple : 

a, b, c = [1, 2, 3]
print(a)
print(b)
print(c)

"""
1
2
3
"""

Nous pouvons également regrouper plusieurs valeurs dans une seule variable à l'aide de * – cette astuce Python est appelée « packing » (emballage). Voici un exemple d'emballage.  

a, *b = 1, 2, 3
print(a, b)
"""
1 [2, 3]
"""

La combinaison de l'emballage et du déballage automatiques donne naissance à une technique appelée « affectation simultanée ». Nous pouvons utiliser l'affectation simultanée pour attribuer une série de valeurs à une série de variables.

N° 3 Liste vs. Tuples 

import sys

a = [1, 2, 3, 4, 5]
b = (1, 2, 3, 4, 5)

print(f"List size: {sys.getsizeof(a)} bytes")
print(f"Tuple size: {sys.getsizeof(b)} bytes")

"""
List size: 52 bytes
Tuple size: 40 bytes
"""

La plupart des programmeurs Python connaissent bien la structure de données liste. Il n'en va pas de même pour les tuples. Ils sont tous deux itérables, permettent l'indexation et autorisent le stockage de types de données hétérogènes. Cependant, il existe des situations dans lesquelles l'utilisation d'un tuple peut être préférable à celle d'une liste. 

Tout d'abord, les listes sont modifiables, ce qui signifie que nous pouvons les modifier à notre convenance : 

a = [1,2,3,4,5]
a[2] = 8
print(a)

"""
[1,2,8,4,5]
"""

Les tuples, en revanche, sont immuables, ce qui signifie que toute tentative de modification entraînera une erreur TypeError. 

Pour cette raison, les tuples sont plus efficaces en termes de mémoire, car Python peut allouer le bloc de mémoire approprié requis pour les données. En revanche, dans une liste, il est nécessaire d'allouer de la mémoire supplémentaire au cas où nous souhaiterions l'étendre. Ce processus est appelé allocation dynamique de mémoire. 

TLDR; Dans les cas où vous ne souhaitez pas que les données soient modifiées, il est préférable d'utiliser une structure de données de type tuple plutôt qu'une liste pour des raisons de mémoire. Les tuples sont également plus rapides que les listes. 

Découvrez les structures de données Python dans ce tutoriel. 

N° 4 Générateurs

a = [x * 2 for x in range(10)]
b = (x * 2 for x in range(10))

print(a)
print(b)

"""
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
<generator object <genexpr> at 0x7f61f8808b50>
"""

Les compréhensions de listes constituent la méthode Python pour créer une liste à partir d'un autre itérable. Elles sont beaucoup plus rapides que l'utilisation d'une boucle « for ». Cependant, que se produit-il si vous modifiez accidentellement les crochets de [] à ()? Vous obtenez un objet générateur.

En Python, les parenthèses avec la logique de compréhension de liste créent ce que l'on appelle un objet générateur. Les générateurs constituent un type particulier d'itérables. Contrairement aux listes, elles ne stockent pas leurs éléments. Au lieu de cela, ils stockent les instructions permettant de générer chaque élément dans l'ordre et l'état actuel des itérations.

Chaque élément n'est généré que sur demande à l'aide d'une technique appelée évaluation paresseuse. Le principal avantage de cette astuce Python utilisant un générateur est qu'elle utilise moins de mémoire, car la séquence entière n'est pas construite en une seule fois. 

#5 Aliasing 

a = [1, 2, 3, 4 ,5]
b = a

# Change the 4th index in b
b[4] = 7

print(id(a))
print(id(b))
print(a) # Remember we did not explicitly make changes to a.

"""
15136008
15136008
[1, 2, 3, 4, 7]
"""

Python est un langage de programmation orienté objet - tout est un objet. Ainsi, attribuer un objet à un identifiant revient à créer une référence à cet objet. 

Lorsque nous attribuons un identifiant à un autre identifiant, nous obtenons deux identifiants qui font référence au même objet. Ce concept est connu sous le nom d'aliasing. Les modifications apportées à un alias affecteront l'autre. Parfois, ce comportement est souhaité, mais souvent, il nous prend au dépourvu. 

Une solution consiste à éviter l'aliasing lors de l'utilisation d'objets mutables. Une autre solution pourrait consister à créer un clone de l'objet original plutôt qu'une référence. 

La méthode la plus simple pour créer un clone consiste à utiliser le découpage : 

b = a[:] 

Cela créera une nouvelle référence à un objet liste dans l'identificateur b. 

Il est possible de concevoir de nombreuses autres solutions, comme appeler list(a) lors de l'affectation des données à un autre identifiant et utiliser la méthode copy(). 

#6 L'opérateur « not »

a = []
print(not a)

"""
True
"""

Notre prochaine astuce Python consiste en la méthode la plus simple pour vérifier si votre structure de données est vide en utilisant l'opérateur not. Python dispose d'une fonction intégrée appelée not est un opérateur logique qui renvoie True si l'expression n'est pas vraie, ou False dans le cas contraire. Il inverse la valeur de vérité des expressions et des objets booléens.  

Une autre utilisation possible est dans une instruction if : 

if not a:
    # do something... 

Lorsque a est vrai alors le non renvoie Faux, et inversement. 

C'est un peu complexe à appréhender, alors essayez. 

#7 Cordes F

first_name = "John"
age = 19

print(f"Hi, I'm {first_name} and I'm {age} years old!")

"""
Hi, I'm John and I'm 19 years old!
"""

Il peut parfois être nécessaire de formater un objet chaîne ; Python 3.6 a introduit une fonctionnalité intéressante appelée f-strings afin de simplifier ce processus. Il est utile de comprendre comment les chaînes étaient formatées avant la nouvelle version afin de mieux apprécier la nouvelle méthode. 

Voici comment les chaînes étaient formatées auparavant : 

first_name = "John"
age  = 19

print("Hi, I'm {} and I'm {} years old!".format(first_name, age))

"""
Hi, I'm John and I'm 19 years old!
"""

Essentiellement, la nouvelle méthode de formatage est plus rapide, plus lisible, plus concise et réduit les risques d'erreurs.

Une autre utilisation des chaînes f consiste à afficher un nom d'identifiant avec la valeur. Cette fonctionnalité a été introduite dans Python 3.8.

x = 10
y = 20
print(f"{x = }, {y = }")

"""
x = 10, y = 20
"""

Veuillez consulter ce tutoriel sur le formatage des chaînes F en Python pour en savoir plus. 

#8 Le paramètre « end » des fonctions d'impression

languages = ["english", "french", "spanish", "german", "twi"]
print(' '.join(languages))

"""
english french spanish german twi
"""

Il est assez courant d'utiliser un impression sans définir aucun de ses paramètres optionnels. Par conséquent, plusieurs utilisateurs de Python ignorent qu'il est possible de contrôler la sortie dans une certaine mesure.

Un paramètre facultatif que nous pouvons modifier est end. Le paramètre end spécifie ce qui doit être affiché à la fin d'un appel à une print . 

La valeur par défaut de end est « \n », qui indique à Python de commencer une nouvelle ligne. Dans le code ci-dessus, nous l'avons remplacé par un espace. Ainsi, le résultat renvoyé affiche tous les éléments de notre liste sur la même ligne.

#9 Ajouter à un tuple

a = (1, 2, [1, 2, 3])
a[2].append(4)
print(a)

"""
(1, 2, [1, 2, 3, 4])
"""

Nous savons déjà que les tuples sont immuables – voir l'astuce Python #3 Liste vs. . Tenter de modifier l'état d'un tuple entraînerait une erreur TypeError. Cependant, si l'on considère un objet tuple comme une séquence de noms liés à des objets qui ne peuvent être modifiés, on peut percevoir les choses différemment.

Les deux premiers éléments de notre tuple sont des entiers ; ils sont immuables. Le dernier élément de notre tuple est une liste, un objet modifiable en Python.

Si nous considérons notre liste comme un simple nom dans une séquence liée à un objet qui ne peut être modifié, nous nous rendons compte que la liste peut toujours être modifiée à partir du tuple.

Recommanderions-nous de procéder ainsi dans la pratique ? Probablement pas, mais c'est une information intéressante à connaître.

N° 10 Fusionner des dictionnaires

a = {"a": 1, "b": 2}
b = {"c": 3, "d": 4}

a_and_b = a | b
print(a_and_b)

"""
{"a": 1, "b": 2, "c": 3, "d": 4}
"""

Dans Python 3.9 et les versions ultérieures, il est possible de fusionner des dictionnaires à l'aide de | (OU bit à bit). Il n'y a pas grand-chose d'autre à dire sur cette astuce Python particulière, si ce n'est qu'il s'agit d'une solution beaucoup plus lisible.  

N° 11 Opérateur ternaire / Expressions conditionnelles 

condition = True
name = "John" if condition else "Doe"

print(name)

"""
John
"""

Dans le code ci-dessus, vous pouvez observer ce que l'on appelle un opérateur ternaire, également appelé expression conditionnelle parmi les noms. Nous utilisons des opérateurs ternaires pour évaluer des éléments en fonction de la vérification d'une condition. vrai ou fausse.

Une autre manière d'écrire le code ci-dessus aurait été la suivante :

condition = True
if condition:
    name = "John"
else:
    name = "Doe"

print(name)
"""
John
"""

Bien que les deux ensembles de code produisent le même résultat, veuillez noter comment l'instruction conditionnelle ternaire nous permet d'écrire un code beaucoup plus court et plus clair. C'est ce que les adeptes de Python qualifieraient de manière plus « pythonesque » d'écrire du code. 

#12 Supprimer les doublons des listes

a = [1, 1, 2, 3, 4, 5, 5, 5, 6, 7, 2, 2]
print(list(set(a)))

"""
[1, 2, 3, 4, 5, 6, 7]
"""

La méthode la plus simple pour supprimer les éléments en double d'une liste consiste à convertir la liste en un ensemble (puis à la reconvertir en liste si nécessaire).

En termes de mutabilité, les ensembles et les listes sont assez similaires en Python. Nous pouvons ajouter et supprimer des éléments des deux structures de données à notre convenance, mais elles restent néanmoins très différentes.

Les listes sont ordonnées, indexées à partir de zéro et modifiables. Les ensembles ne sont ni ordonnés ni indexés. Les éléments d'un ensemble doivent être de type immuable, même si l'ensemble lui-même est mutable. Toute tentative de récupération d'un élément via un index ou de modification d'un élément entraînera une erreur.

Une autre différence importante entre les ensembles et les listes réside dans le fait que les ensembles ne peuvent pas contenir de doublons. C'est ce qui nous a permis de supprimer les éléments en double de notre liste.

N° 13 : Underscore autonome 

>>> print(_)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>

>>> 1 + 2
3

>>> print(_)
3

Le trait de soulignement (_) est un identifiant légal en Python, il est donc possible de l'utiliser pour référencer un objet. Cependant, underscore a également une autre responsabilité : stocker le résultat de la dernière évaluation.

La documentation indique que « l'interpréteur interactif rend le résultat de la dernière évaluation disponible dans la variable _. (Il est stocké dans le module builtins, aux côtés des fonctions intégrées telles que print).

Étant donné que nous n'avons pas attribué d'objet à underscore avant de l'appeler à la première ligne, nous avons obtenu une erreur. Cependant, lorsque nous avons calculé le résultat de 1 + 2, l'interpréteur interactif a enregistré le résultat dans l'identifiant _ pour nous. 

#14 Souligner pour ignorer les valeurs

for _ in range(100):
    print("The index doesn't matter")

"""
The index doesn't matter
The index doesn't matter
...
"""

Dans l'astuce Python n° 13, nous avons découvert que l'interpréteur interactif rendait le dernier résultat d'une évaluation disponible dans l'identifiant underscore (_), mais ce n'est pas son seul cas d'utilisation.

Nous pouvons également l'utiliser pour représenter des objets qui ne nous intéressent pas ou que nous n'utiliserons pas plus tard dans le programme. Ceci est important car l'utilisation d'un identifiant à la place d'un trait de soulignement (_) entraînera une erreur F841 lorsque nous tenterons d'effectuer un linting sur notre programme. Une erreur F841 indique simplement qu'un nom de variable locale a été attribué mais n'a pas été utilisé dans le programme, ce qui est une mauvaise pratique.

N° 15 : Trailing Underscores

list_ = [0, 1, 2, 3, 4]
global_ = "Hi there" 

Dans la continuité des deux astuces précédentes, l'utilisation du trait de soulignement (_) en Python a également pour objectif d'éviter les conflits avec les mots-clés Python. 

La PEP 8 indique qu'un trait de soulignement (_) final doit être « utilisé par convention afin d'éviter tout conflit avec les mots-clés Python ». Il est également indiqué qu'il est généralement préférable d'ajouter un seul trait de soulignement à la fin plutôt que d'utiliser une abréviation ou une orthographe incorrecte. Par conséquent, list_ est préférable à lst.

N° 16 : Les traits d'union en début de ligne

class Example:
    def __init__(self):
        self._internal = 2
        self.external = 20

Vous remarquerez souvent que les programmeurs Python expérimentés ont tendance à ajouter un trait de soulignement devant un identifiant ou un nom de méthode, et ce pour une bonne raison.

Le trait de soulignement placé devant un identifiant ou une méthode a une signification cachée : cette variable ou cette méthode est uniquement destinée à un usage interne. Il s'agit essentiellement d'une clause de non-responsabilité à l'intention des autres programmeurs, qui a été définie dans la PEP 8 mais qui n'est pas appliquée par Python. Par conséquent, les indicateurs avancés constituent un indicateur peu fiable.

Contrairement à Java, Python ne fait pas de distinction stricte entre les variables privées et publiques. En d'autres termes, cela n'a de sens que parce que la communauté Python a convenu que cela ait un sens. Leur inclusion n'a aucune incidence sur le comportement de vos programmes.

N° 17 Souligner visuellement

Voici le dernier conseil concernant les traits de soulignement. Jusqu'à présent, nous avons abordé trois cas d'utilisation différents du trait de soulignement, mais vous pouvez consulter notre tutoriel pour en savoir plus sur le rôle du trait de soulignement (_) en Python. 

number = 1_500_000
print(number)

"""
15000000
"""

Une autre utilisation possible du trait de soulignement est celle de séparateur visuel pour le regroupement de chiffres dans les littéraux intégraux, à virgule flottante et complexes. Cette fonctionnalité a été introduite dans Python 3.6. 

L'objectif était d'améliorer la lisibilité des littéraux longs ou des littéraux dont la valeur doit être clairement séparée en plusieurs parties. Vous pouvez en savoir plus à ce sujet dans la PEP 515.

#18 __name__ == « __main__ » 

if __name__ == "__main__":
    print("Read on to understand what is going on when you do this.")

"""
print("Read on to understand what is going on when you do this.")
"""

Il est fort probable que vous ayez déjà rencontré cette syntaxe dans plusieurs programmes Python ; Python utilise un nom spécial appelé « __main__ » et le définit comme identifiant appelé __name__ si le fichier Python exécuté est le programme principal.

Si nous décidons d'importer le module affiché dans la capture d'écran dans un autre module (fichier Python) et d'exécuter ce fichier, l'expression dans notre code sera fausse. En effet, lorsque nous importons depuis un autre module, l'identifiant __name__ est défini sur le nom du module (fichier Python). 

#19 La méthode « setdefault » 

import pprint

text = "It's the first of April. It's still cold in the UK. But I'm going to the museum so it should be a wonderful day"

counts = {}
for word in text.split():
    counts.setdefault(word, 0)
    counts[word] += 1

pprint.pprint(counts)

"""
{'April.': 1,
'But': 1,
"I'm": 1,
"It's": 2,
'UK.': 1,
'a': 1,
'be': 1,
'cold': 1,
'day': 1,
'first': 1,
'going': 1,
'in': 1,
'it': 1,
'museum': 1,
'of': 1,
'should': 1,
'so': 1,
'still': 1,
'the': 3,
'to': 1,
'wonderful': 1}
"""

Vous pouvez définir une valeur pour différentes clés dans un dictionnaire. Par exemple, lorsque vous effectuez un cursus du nombre de mots dans un corpus. La méthode courante pour procéder est la suivante : 

1. Vérifiez si la clé est présente dans le dictionnaire.
2. Si c'est le cas, augmentez la valeur de 1.
3. Si ce n'est pas le cas, veuillez l'ajouter et définir la valeur sur 1.

Voici à quoi cela ressemble dans le code :

counts = {}
for word in text.split():
    if word in counts:
        counts[word] += 1
    else:
      counts[word] = 1

Une méthode plus concise consiste à utiliser la méthode setdefault() sur votre objet dictionnaire.

Le premier argument transmis à la méthode est la clé que nous souhaitons vérifier. Le deuxième argument transmis est la valeur à attribuer à la clé si celle-ci n'existe pas encore dans le dictionnaire. Si la clé existe, la méthode renvoie la valeur de la clé. Par conséquent, cela ne serait pas modifié.

#20 Correspondance d'expressions régulières

import re

number = re.compile(r"(0)?(\+44)?\d{10}")
num_1 = number.search("My number is +447999999999")
num_2 = number.search("My number is 07999999999")

print(num_1.group())
print(num_2.group())

"""
'+447999999999'
'07999999999'
"""

Les expressions régulières vous permettent de spécifier un modèle de texte à rechercher. La plupart des gens savent qu'il est possible d'effectuer une recherche à l'aide de la combinaison CTRL + F (Windows), mais si vous ne connaissez pas exactement ce que vous recherchez, comment pourriez-vous le trouver ? La solution consiste à rechercher des modèles.  

Par exemple, les numéros britanniques suivent un modèle similaire : ils comportent un zéro au début suivi de dix chiffres ou +44 au lieu du zéro et des dix chiffres – le second cas indique qu'il s'agit du format international. 

Les expressions régulières permettent un gain de temps considérable. Si nous devions coder des règles pour détecter les instances dans notre image au lieu d'utiliser des expressions régulières, cela pourrait nécessiter plus de 10 lignes de code. 

Il est essentiel de comprendre le fonctionnement des expressions régulières, même si vous ne programmez pas. La plupart des éditeurs de texte et des traitements de texte modernes vous permettent d'utiliser des expressions régulières pour rechercher et remplacer des éléments.

#21 Pipe Regex

import re

heros = re.compile(r"Super(man|woman|human)")

h1 = heros.search("This will find Superman")
h2 =  heros.search("This will find Superwoman")
h3 = heros.search("This will find Superhuman")

print(h1.group())
print(h2.group())
print(h3.group())

"""
Superman
Superwoman
Superhuman
"""

Les expressions régulières disposent d'un caractère spécial appelé pipe (|) qui permet de faire correspondre l'une parmi plusieurs expressions, et elles peuvent être utilisées n'importe où. Ceci est extrêmement pratique lorsque vous disposez de plusieurs modèles similaires.

Par exemple, « Superman », « Superwoman » et « Superhuman » ont tous le même préfixe. Ainsi, vous pourriez utiliser le tuyau pour conserver la partie récurrente du motif et modifier les parties qui doivent être différentes. Une fois de plus, nous vous faisons gagner un temps précieux.

Veuillez noter que si toutes les expressions que vous souhaitez faire correspondre apparaissent dans le même texte, la première occurrence du texte correspondant sera renvoyée. Par exemple, « Un exemple de texte contenant Superwoman, Superman, Superhuman » renverrait Superwoman.

#22 Le paramètre « sep » de la fonction d'impression

day = "04"
month = "10"
year = "2022"

print(day, month, year)
print(day, month, year, sep = "")
print(day, month, year, sep = ".")

"""
04 10 2022
04/10/2022
04.10.2022
"""

Le nombre de programmeurs Python qui ne connaissent pas toutes les capacités de la fonction print() est préoccupant. Si « Hello World » a été votre premier programme, la fonction print() a probablement été l'une des premières fonctions intégrées que vous avez apprises lors de votre apprentissage de Python. Nous utilisons print() pour afficher des messages formatés à l'écran, mais la fonction print() offre bien d'autres possibilités. 

Dans le code ci-dessus, nous avons présenté différentes méthodes pour afficher notre message formaté. Le paramètre sep est un argument facultatif de la fonction print() qui nous permet de spécifier comment les objets doivent être séparés si nous en incluons plusieurs. 

Par défaut, ils sont séparés par un espace, mais nous avons modifié cette fonctionnalité avec nos instructions d'impression : l'une où sep est défini sur « » et l'autre où sep est défini sur « . ».

#23 Fonctions lambda 

def square(num:int) -> int:
    return num ** 2

print(f"Function call: {square(4)}")
"""
Function call: 16
"""

square_lambda = lambda x: x**2
print(f"Lambda function: {square_lambda(4)}")
"""
Lambda functional: 16
"""

Les fonctions Lambda vous permettent d'accéder à des fonctionnalités Python de niveau intermédiaire à avancé. Apprenez le Python intermédiaire grâce à ce cours. À première vue, ils semblent complexes, mais ils sont en réalité assez simples.

Dans notre exemple de code, nous n'avons utilisé qu'un seul argument, mais nous aurions pu en utiliser plusieurs si nous l'avions souhaité :

square = lambda a, b: a ** b
print(f"Lambda function: {square(4, 2)}")
"""
16
"""

En substance, le mot-clé lambda nous permet de créer de petites fonctions anonymes et restreintes en une seule ligne. Elles se comportent comme une fonction régulière déclarée avec un mot-clé def, à l'exception que ces fonctions n'ont pas de nom.

#24 La méthode « swapcase »

string = "SoMe RaNDoM sTriNg"
print(string.swapcase())

"""
sOmE rAndOm StRInG
"""

La méthode swapcase() est appliquée à un objet chaîne de caractères afin de nous permettre de convertir les lettres majuscules en minuscules et inversement en une seule ligne de code. Il existe peu de cas d'utilisation de la méthode swapcase(), mais il est utile de la connaître.

Méthode « isalnum »

password = "ABCabc123"
print(password.isalnum())

"""
True
"""

Supposons que nous développions un programme qui exige des utilisateurs qu'ils saisissent un mot de passe, mais celui-ci doit être composé d'une combinaison de chiffres et de lettres. Nous pouvons réaliser cela en une seule ligne de code en appelant la fonction isalnum() sur l'instance de chaîne.

Cette méthode vérifie si tous les caractères appartiennent à l'alphabet (A-Za-z) et sont numériques (0-9). Un espace ou un symbole (!#%$&? etc.) renverra faux.

#26 Gestion des exceptions

def get_ration(x:int, y:int) -> int:
    try:
        ratio = x/y
    except ZeroDivisionError:
        y = y + 1
        ratio = x/y
    return ratio

print(get_ration(x=400, y=0))

"""
400.0
"""

Les programmes Python s'arrêtent lorsqu'ils rencontrent une erreur.

Parfois, nous ne souhaitons pas ce comportement, par exemple lorsqu'un utilisateur final interagit avec notre code. Quel serait l'impact si notre code se terminait prématurément dans un tel cas ?

Il existe plusieurs approches pour traiter ce cas particulier. La plupart des programmeurs Python adhèrent généralement à l'idée qu'il est plus facile de demander pardon que d'obtenir la permission. Cela signifie qu'ils préfèrent détecter une erreur levée en fournissant un contexte environnant capable de gérer une exception. L'idée derrière cette réflexion est qu'il est inutile de perdre du temps à essayer de se prémunir contre tous les cas exceptionnels.

Cependant, cela n'est valable que lorsqu'il existe un mécanisme permettant de faire face à un problème après qu'il se soit produit.

#27 Identifier les différences dans les listes

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

solution_1 = list(set(list_2) - set(list_1))
solution_2 = list(set(list_1) ^ set(list_2))
solution_3 = list(set(list_1).symmetric_difference(set(list_2)))

print(f"Solution 1: {solution_1}")
print(f"Solution 2: {solution_2}")
print(f"Solution 3: {solution_3}")

"""
Solution 1: [9, 2, 4, 6]
Solution 2: [2, 4, 6, 9]
Solution 3: [2, 4, 6, 9]
"""

Voici trois méthodes différentes pour comparer la différence entre deux listes en Python. 

Remarque: À moins que vous ne soyez certain que list_1 est un sous-ensemble de list_2, la solution 1 n'est pas identique aux deux autres solutions.

#28 Args et Kwargs

def some_function(*args, **kwargs):
    print(f"Args: {args}")
    print(f"Kwargs: {kwargs}")

some_function(1, 2, 3,  a=4, b=5, c=6)

"""
Args: (1, 2, 3)
Kwargs: {'a': 4, 'b': 5, 'c': 6}
"""

Nous utilisons *args et **kwargs comme paramètres d'une fonction lorsque nous ne connaissons pas le nombre de variables que notre fonction doit attendre. 

Le paramètre *args nous permet de transmettre un nombre variable de paramètres à une fonction lorsqu'elle n'est pas associée à un mot-clé (c'est-à-dire que les paramètres que nous transmettons ne nécessitent pas de nom associé). D'autre part, le paramètre **kwargs nous permet de transmettre un nombre arbitraire de paramètres clés à une fonction.

En réalité, les mots *args et **kwargs ne sont pas si magiques : la véritable magie réside dans les astérisques (*). Cela signifie que nous aurions pu utiliser n'importe quel mot après les astérisques, mais l'utilisation de args et kwargs est une pratique courante, et elle est appliquée par les développeurs Python. 

N° 29 Les points de suspension

print(...)

"""
Ellipsis
"""

def some_function():
    ...

# Alternative solution
def another_function():
    pass

Ellipsis est un objet Python qui peut être appelé en fournissant une séquence de trois points (...) ou en appelant l'objet lui-même (Ellipsis).

Son utilisation la plus notable est l'accès et le découpage de tableaux multidimensionnels dans NumPy, par exemple :

import numpy as np

arr = np.array([[2,3], [1,2], [9,8]])

print(arr[...,0])
"""
[2 1 9]
"""
print(arr[...])

"""
[[2 3]
[1 2]
[9 8]]
"""

Cependant, Ellipsis peut également être utilisé comme espace réservé dans une fonction non implémentée. 

Cela signifie que vous pourriez transmettre Ellipsis, ..., ou pass, et ils seraient tous valides.

N° 30 Compréhension des listes

even_numbers = [x for x in range(10) if x % 2 == 0 and x != 0]
print(even_numbers)

"""
[2, 4, 6, 8]
"""

Notre dernière astuce Python concerne les compréhensions de listes, une méthode élégante pour créer une liste à partir d'une autre séquence. Ils vous permettent d'effectuer des opérations logiques et de filtrage sophistiquées, comme nous l'avons fait dans le code ci-dessus.

Il existe d'autres moyens d'atteindre le même objectif ; par exemple, nous aurions pu utiliser une fonction lambda comme suit :

even_numbers = list(filter(lambda x: x % 2 ==0 and x != 0, range(10)))
print(even_numbers)
"""
[0, 2, 4, 6, 8]
"""

Cependant, plusieurs adeptes de Python pourraient soutenir que cette solution est beaucoup moins lisible que la compréhension de liste.

Veuillez consulter ce tutoriel pour approfondir vos connaissances sur les compréhensions de listes Python.