Python : 7 astuces pour vos fonctions Python

Bonjour à vous, passionnés de Python ! Aujourd’hui, on va se pencher sur un sujet important : les fonctions Python.

On va découvrir ensemble sept astuces qui vous aideront à maîtriser l’art de la programmation fonctionnelle Python !

Pour une maîtrise complète de l’outil, suivez notre formation Python. Devenez un expert Python en participant à notre formation complète. Apprenez les bases du langage et progressez vers des niveaux avancés pour devenir un codeur Python accompli.

L’équipe Ambient IT

1 – Optimisez votre code avec des annotations de Type

Annotations de Type en Python :

Les annotations de type, c’est quoi ? Une fonctionnalité puissante qui a été introduite dans Python 3.

Grosso modo, elles vont vous permettre d’indiquer les types d’arguments et de retour des fonctions. Ça va rendre le code plus lisible et plus facile à comprendre.

Vous pouvez écrire des fonctions comme celle-ci parce que Python est typé de manière dynamique. Ce qui signifie que les types de données des variables sont déterminés à l’exécution.

def magic(a:int, b:int) -> int:
  return a + b

Réécrivez exactement la même fonction que ci-dessus, mais avec des indications de type.

‘a‘ doit être un entier.
‘b‘ doit être un entier.
La valeur de retour de la fonction doit également être un entier

Lorsque votre base de code devient énorme, l’annotation de type devient de plus en plus importante pour rendre votre code aussi lisible que possible. Imaginez 10 000 fonctions où vous devez deviner les types de données qu’elles prennent et leurs types de retour. Pas très amusant !

def test1(ls: list[int], x:float) -> list[float]:
  # stuff

‘ls‘ doit être une liste de nombres flottants.
‘x‘ doit être un nombre flottant.
La fonction doit renvoyer une liste de nombres flottants.

def test2(a:str, b:bool, c:dict[str,str]) -> dict[str,int]:
  # stuff

‘a‘ doit être une chaîne de caractères.
‘b‘ doit être une valeur booléenne.
‘c‘ doit être un dictionnaire où les clés sont et les valeurs sont des chaînes de caractères. La valeur de retour doit être un dictionnaire où les clés sont des chaînes, mais les valeurs sont des entiers.

/!\ À savoir : Les indications de type sont des indications, pas des contraintes. Si vous ne suivez pas le type indiqué, Python s’exécutera toujours.

**2 – Flexibilité avec *args et kwargs

Les *args et **kwargs sont des fonctionnalités puissantes de Python, qui vont servir à traiter un nombre de variables d’arguments dans une fonction.

Mais comment utiliser *args et **kwargs pour rendre vos fonctions plus flexibles et polyvalentes ?

def magic(*args, **kwargs):
  print('args =', args)
  print('kwargs =', kwargs)

Cette fonction va permettre de définir des fonctions qui prennent un nombre infini d’arguments positionnels avec *args. Et un nombre infini d’arguments par mot-clé avec **kwargs.

magic(1, 2, 'apple', a=4, b=5, c=[1, 2, 3])

Dans cet exemple, 1, 2 et ‘apple’ sont des arguments positionnels, tandis que a=4, b=5 et c=[1,2,3] sont des arguments par mot-clé.

magic(1, 2, 'apple', a=4, b=5, c=[1, 2, 3])

# args = (1, 2, 'apple')
# kwargs = {'a':4, 'b':5, 'c':[1, 2, 3]}

Tous les arguments positionnels sont capturés sous forme de tuple args, et tous les arguments par mot-clé sont capturés sous forme de dictionnaire kwargs.

3 – Simplifiez vos fonctions avec des fonctions lambdas

Kézako ? Ce sont des fonctions anonymes qui peuvent être définies en une seule ligne. On va faire un exemple assez simple :

def add(x, y):
  return x + y

Réécrivons cela sous forme de fonction lambda :

add = lambda x, y: x + y

Les entrées de la fonction sont positionnées avant et la valeur de retour vient après :

# another example

def add10(x):
  return x + 10

# SAME AS
add10 = lambda x: x+10

Dans cet exemple, nous avons réécrit la fonction add en tant que fonction lambda. Les fonctions lambda peuvent être anonymes, ce qui signifie que nous n’avons pas besoin de leur donner un nom si nous ne le voulons pas. Ce qui peut être utile si nous devons passer une fonction dans une autre fonction.

def apply(func, x):
  return func(x)

x = apply(lambda x:x+10, 7)
print(x)    # 17

Dans cet exemple, nous utilisons une fonction lambda pour ajouter 10 à un nombre. Nous passons ensuite cette fonction lambda à une autre fonction apply, qui l’applique à un nombre spécifique, produisant le résultat 17.

4 – Les fonctions d’ordre supérieur

Ces fonctions prennent d’autres fonctions (Inception…) en tant qu’arguments ou qui renvoient des fonctions.

def apply(func, x):
  return func(x)

Dans notre exemple précédent, la fonction apply est une fonction d’ordre supérieur car elle prend une autre fonction, func, en argument.

x = apply(lambda x:x+10, 7)
print(x)    # 17

Dans cet exemple, nous utilisons une fonction lambda comme argument de la fonction apply, ce qui la rend également une fonction d’ordre supérieur.

Vous seriez surpris du nombre de fonctions d’ordre supérieur présentes dans les bases de code d’entreprise. Il est donc probablement judicieux de vous familiariser avec leur utilisation !

5 – Décorez votre code avec des décorateurs

Les décorateurs sont une forme spéciale de fonction d’ordre supérieur. L’intention d’un décorateur est de modifier le comportement d’une autre fonction sans changer son code source.

Notez qu’une fonction décoratrice prend une fonction en argument et renvoie une fonction.

def add_exclamation(func):
  def wrapper(name):
    return func(name) + '!'
  return wrapper

Dans cet exemple, add_exclamation est la fonction décoratrice. Elle prend une fonction hello en argument et renvoie une nouvelle fonction wrapper qui modifie légèrement le comportement de la fonction d’origine.

def hello(name):
  return 'hello ' + name

hello = add_exclamation(hello)

Nous appliquons le décorateur à la fonction hello en lui attribuant le résultat de l’appel à add_exclamation avec hello comme argument.

print(hello('tom'))    # hello tom!

Maintenant, le comportement de notre fonction a légèrement changé. Elle ajoute maintenant un point d’exclamation à la fin du message.

@add_exclamation
def hello(name):
  return 'hello ' + name

print(hello('tom'))    # hello tom!

Nous pouvons également utiliser la syntaxe @add_exclamation pour décorer notre fonction hello. Cela produit exactement le même effet que la méthode précédente.

Les décorateurs sont utilisés :

Dans les bases de code d’entreprise pour la journalisation
La synchronisation
La gestion des exceptions
L’authentification
Les API REST

Il est donc probablement judicieux de vous familiariser également avec les décorateurs !

6 – Générez des résultats à la demande avec Les fonctions génératrices

Une fonction devient une fonction génératrice lorsque nous utilisons yield. yield est similaire au mot-clé return en ce sens qu’il renvoie une valeur à partir d’une fonction, mais yield ne stoppe pas la fonction entièrement comme le fait return.

# fonction normale
def test():
  return [1, 2, 3]

x = test()
print(x)    # [1, 2, 3]

Dans cet exemple, test est une fonction normale qui renvoie une liste.

# fonction génératrice, mais nous l'appelons comme une fonction normale
def test():
  yield 1
  yield 2
  yield 3

x = test()
print(x)    # <generator object x at 0x1029b4a90>

Dans cet exemple, test est une fonction génératrice. Lorsque nous l’appelons, elle renvoie un générateur objet.

# fonction génératrice, mais nous l'appelons en utilisant une boucle
def test():
  yield 1
  yield 2
  yield 3

for i in test():
  print(i, end=' ')

# 1 2 3

Les fonctions génératrices sont évaluées de manière paresseuse – ce qui signifie qu’elles ne font le travail que lorsque c’est absolument nécessaire (lorsque nous utilisons une boucle). Ce qui peut en fait rendre notre code plus efficace.

7- Explorez les Méthodes Dunder

Ces méthodes sont présentes partout dans le code Python d’entreprise, surtout lorsque la programmation orientée objet est impliquée.

Une méthode spéciale commence et se termine par 2 caractères de soulignement, par exemple init, str, getitem, add, et ainsi de suite. Elles définissent un comportement spécial dans les classes Python.

class Dog:
  # définit comment les attributs sont assignés au chien
  def __init__(self, name, age):
    self.name, self.age = name, age

  # définit ce qui est renvoyé lorsque nous utilisons str(chien)
  def __str__(self):
    return 'Chien!'

  # définit ce qui est renvoyé lorsque nous faisons chien + quelque chose
  def __add__(self, something):
    return 'Chien ' + str(something)

  # définit ce qui est renvoyé lorsque nous faisons chien[something]
  def __getitem__(self, something):
    return 123

Conclusion

On est déjà à la fin, et vous avez dorénavant sept astuces pour maîtriser la programmation fonctionnelle en Python ! Alors à vos claviers et que la magie Python commence !