Fonctions avancées en Python. Partie 8 Cours de Python de débutant à avancé en 11 articles de blog

Cet article aidera le lecteur à continuer à partir du précédent blog sur les fonctions Python, ainsi qu’à explorer quelques applications de base dans le monde réel. Nous utiliserons Visual Studio Code comme éditeur de code. Si vous n’avez pas installé Visual Studio Code, les instructions sont données dans le premier blog.

Fonctions avancées en Python – table des matières :

1. Passer des fonctions à d’autres fonctions
2. Utiliser des fonctions à l’intérieur d’une fonction
3. *Args en Python
4. Opérateur “*” en Python
5. **kwargs en Python

Passer des fonctions à d’autres fonctions

Comme discuté dans le blog précédent, les fonctions en Python sont traitées comme des objets. Donc, comme les objets en Python, les fonctions peuvent également être passées en tant qu’argument à une autre fonction.

Par exemple :

def mul(x, y):
    return x*y
 
 
def add(mul, y):
    return mul+y
 
 
x = add(mul(9, 10), 10)
print(x)

Dans le bloc de code ci-dessus, on peut voir que la fonction mul est passée en tant qu’argument à la fonction add et qu’elle est stockée dans la variable x qui est ensuite imprimée pour vérifier la réponse.

100

Utiliser des fonctions à l’intérieur d’une fonction

En Python, nous pouvons définir une fonction à l’intérieur d’une autre fonction. Ces fonctions sont appelées fonctions imbriquées. Mais dans ce cas d’utilisation, la fonction interne ou imbriquée ne peut pas être appelée séparément. Les deux exemples sont illustrés dans le bloc de code suivant.

Écrivons notre première fonction.

def mul(x, y):
 
    m = x*y
 
    def square(m):
        return m*m
 
    return square(m)
 
 
x = mul(9, 10)
 
print(x)

Sortie :
8100

Dans le bloc de code ci-dessus, la fonction externe est “mul” qui renvoie la fonction square qui prend un argument “m” qui est le produit de deux arguments donnés à la fonction “mul”. L’exécution du code commence d’abord par l’appel de la fonction “mul”, puis le produit de “x” et “y” est stocké dans la variable “m”. Comme cette fonction renvoie la fonction square, la fonction “square” est appelée et le produit final qui est le carré de “m” est renvoyé.

Apprenons quelques choses importantes en Python, qui rendront votre parcours de codage avec Python beaucoup mieux.

*Args en Python

Ce sont les arguments que nous utilisons comme paramètres de fonction. Écrivons une fonction habituelle en utilisant ce que nous avons appris jusqu’à présent. Nous allons écrire une fonction qui peut nous donner la superficie maximale d’un rectangle donné 2 superficies de rectangles comme paramètres de la fonction.

def maxarea(a, b):
    if a > b:
        return f'le rectangle a a la plus grande superficie qui est {a}'
    else:
        return f'le rectangle a a la plus grande superficie qui est {b}'
 
 
x = maxarea(100, 60)
print(x)
 

Sortie :
le rectangle a a la plus grande superficie qui est 100
[code lang="js"]

Cette fonction est bonne pour 2 paramètres ou arguments, mais que faire si nous devons comparer plus de 2 superficies. Une approche consisterait à passer une liste de superficies dans la fonction.

def maxarea(lis):
 
    max = 0
    for i in lis:
        if i > max:
            max = i
 
    return f"le rectangle qui a la plus grande superficie est {max}"
 
 
x = maxarea([100, 60, 50])
print(x)

Sortie :
le rectangle qui a la plus grande superficie est 100

Cette approche est bonne, mais nous devrions connaître le nombre de paramètres ou d’arguments à donner à l’avance. Dans l’exécution de code en temps réel, cela serait un casse-tête. Ainsi, pour faciliter la vie du programmeur, Python utilise *args et **kwargs.

Opérateur “*” en Python

Cet opérateur est un opérateur de déballage qui est généralement utilisé pour passer un nombre non spécifié de paramètres ou d’arguments.

Déballage des arguments dans un tuple en utilisant l’opérateur *

Comme nous l’avons vu, l’opérateur “*” est utilisé pour déballer des valeurs. L’exemple est illustré ci-dessous.

x = [1, 2, 3, 4]
y = [5, 6, 7, 8]
 
z = *x, *y
 
print(type(z))
print(z)

Sortie :
<class 'tuple'>
(1, 2, 3, 4, 5, 6, 7, 8)

Comme nous pouvons le voir, l’opérateur de déballage a déballé la liste x et la liste y dans le tuple qui est z. Nous pouvons également voir que le résultat est un tuple.

Écrivons la même fonction en utilisant *Args.

def maxarea(*lis):
 
    max = 0
    for i in lis:
        if i > max:
            max = i
 
    return f"le rectangle qui a la plus grande superficie est {max}"
 
 
x = maxarea(100, 60, 50, 200)
y = maxarea(100, 60, 50, 200, 9000)
z = maxarea(100, 60, 50, 20, 90)
print(x)
print(y)
print(z)

Sortie :
le rectangle qui a la plus grande superficie est 200
le rectangle qui a la plus grande superficie est 9000
le rectangle qui a la plus grande superficie est 100

Dans ce bloc de code, nous pouvons voir que maintenant les arguments sont dynamiques, nous pouvons ajouter n’importe quel nombre d’arguments qui seront déballés dans la fonction maxarea pour nous donner le résultat souhaité. De plus, nous pouvons comparer n’importe quel nombre de superficies dans ce contexte.

**kwargs en Python

Les kwargs sont comme les args mais ils acceptent des arguments positionnels. Ils utilisent l’opérateur ** qui a certaines caractéristiques comme le déballage de plusieurs arguments positionnels de n’importe quelle longueur, peuvent également déballer des dictionnaires, peuvent également être utilisés pour combiner deux dictionnaires.

Fusionner des dictionnaires

a = {"h": 1, "n": 2}
b = {"m": 5, "l": 10}
 
c = {**a, **b}
 
print(type(c))
print(c)
 
Nous pouvons voir à partir du code ci-dessus que nous avons 2 dictionnaires a et b qui sont fusionnés en utilisant l'opérateur ** pour donner un autre dictionnaire.
Sortie :
 
<class 'dict'>
{'h': 1, 'n': 2, 'm': 5, 'l': 10}

Lorsque nous utilisons l’opérateur * au lieu de l’opérateur **, le code pour ce cas est illustré ci-dessous.

a = {"h": 1, "n": 2}
b = {"m": 5, "l": 10}
 
c = {*a, *b}
 
print(type(c))
print(c)

Sortie :
<class 'set'>
{'n', 'l', 'm', 'h'}

Ainsi, lorsque l’opérateur * est utilisé sur deux dictionnaires pour les fusionner, le résultat sera un ensemble contenant uniquement les clés du dictionnaire.

La fonction maxarea utilisant **kwargs est illustrée dans le bloc de code ci-dessous.

def maxarea(**lis):
 
    max = 0
    for i in lis.values():
        if i > max:
            max = i
 
    return f"le rectangle qui a la plus grande superficie est {max}"
 
 
x = maxarea(a=1, b=2, c=3)
y = maxarea(a=1, b=2)
z = maxarea(a=1, b=2, c=3, d=9)
print(x)
print(y)
print(z)

Sortie :
le rectangle qui a la plus grande superficie est 3
le rectangle qui a la plus grande superficie est 2
le rectangle qui a la plus grande superficie est 9

Dans ce blog sur les fonctions avancées en Python, nous avons couvert des sujets tels que passer des fonctions à d’autres fonctions, utiliser des fonctions à l’intérieur d’une fonction, *Args en Python, opérateur “*” en Python, **kwargs en Python, et plus encore. Les sujets suivants qui incluent les classes seront couverts dans le prochain article de blog. Les devoirs concernant les fonctions avancées en Python sont donnés ci-dessous.