Mot-clé de définition Python est utilisé pour définir une fonction, il est placé avant un nom de fonction fourni par l'utilisateur pour créer une fonction définie par l'utilisateur. Dans Python , une fonction est une unité logique de code contenant une séquence d'instructions indentées sous un nom donné à l'aide du déf mot-clé. En Python, le mot-clé def est le plus utilisé mot-clé .
Python def Syntaxe
déf nom_fonction :
instructions de définition de fonction…
Utilisation du mot-clé def
- Dans le cas des classes, le mot-clé def est utilisé pour définir les méthodes d'une classe.
- Le mot-clé def est également requis pour définir la fonction membre spéciale d'une classe comme __init__().
L'application pratique possible est qu'elle offre la fonctionnalité de réutilisabilité du code plutôt que d'écrire le morceau de code encore et encore. Nous pouvons définir une fonction et écrire le code à l'intérieur de la fonction à l'aide du déf mot-clé . Cela sera plus clair dans l’exemple illustré ci-dessous. Il peut éventuellement y avoir de nombreuses applications de def en fonction des cas d'utilisation.
Comment utiliser def en Python ?
Vous trouverez ci-dessous les manières et exemples par lesquels nous pouvons utiliser def dans Python :
- Créer une fonction def sans arguments
- Créer une fonction def pour trouver la soustraction de deux nombres
- Créer une fonction def avec les 10 premiers nombres premiers
- Créer une fonction pour trouver la factorielle d'un nombre
- Exemple de mot-clé Python def avec *args
- Exemple de mot-clé Python def avec **kwargs
- Passer une fonction comme argument
- Exemple de mot-clé Python def avec la classe
Créer une fonction def sans arguments
Dans cet exemple, nous avons créé une fonction définie par l'utilisateur à l'aide du mot-clé def. La fonction imprime simplement le Bonjour comme sortie.
Python3
def> python_def_keyword():> >print>(>'Hello'>)> python_def_keyword()> |
>
>Sortir
Hello>
Créer une fonction def pour trouver la soustraction de deux nombres
Dans cet exemple, nous avons créé un défini par l'utilisateur fonction en utilisant le mot-clé def. Le nom de la fonction est python_def_subNumbers(). Il calcule les différences entre deux nombres.
Python3
# Python3 code to demonstrate> # def keyword> # function for subtraction of 2 numbers.> def> python_def_subNumbers(x, y):> >return> (x>->y)> # main code> a>=> 90> b>=> 50> # finding subtraction> result>=> python_def_subNumbers(a, b)> # print statement> print>(>'subtraction of '>, a,>' and '>, b,>' is = '>, result)> |
>
>Sortir
subtraction of 90 and 50 is = 40>
Créer une fonction def avec les 10 premiers nombres premiers
Dans cet exemple, nous avons créé une fonction définie par l'utilisateur à l'aide du mot-clé def. Le programme définit une fonction appelée python_def_prime() en utilisant le mot-clé def. La fonction prend un seul paramètre n, qui spécifie le nombre de nombres premiers à imprimer.
Python3
# Python program to print first 10> # prime numbers> # A function name prime is defined> # using def> def> python_def_prime(n):> >x>=> 2> >count>=> 0> >while> count for d in range(2, x, 1): if x % d == 0: x += 1 else: print(x) x += 1 count += 1 # Driver Code n = 10 # print statement print('First 10 prime numbers are: ') python_def_prime(n)> |
>
>Sortir
modèle de conception de constructeur
First 10 prime numbers are: 2 3 5 7 11 13 17 19 23 27>
Créer une fonction pour trouver la factorielle d'un nombre
Dans cet exemple, nous avons créé une fonction définie par l'utilisateur à l'aide du mot-clé def. Le programme définit une fonction appelée python_def_factorial() en utilisant le mot-clé def. La fonction prend un seul paramètre n, qui représente le nombre dont factorielle est à calculer.
Python3
# Python program to find the> # factorial of a number> # Function name factorial is defined> def> python_def_factorial(n):> >if> n>=>=> 1>:> >return> n> >else>:> >return> n>*>python_def_factorial(n>->1>)> # Main code> num>=> 6> # check is the number is negative> if> num <>0>:> >print>(>'Sorry, factorial does not exist for negative numbers'>)> elif> num>=>=> 0>:> >print>(>'The factorial of 0 is 1'>)> else>:> >print>(>'The factorial of'>, num,>'is'>, python_def_factorial(num))> |
>
>Sortir
The factorial of 6 is 720>
Exemple de mot-clé Python def avec *args
Il s'agit d'un programme Python qui définit une fonction appelée python_def_keyword() en utilisant le mot-clé def. La fonction utilise le paramètre spécial *arguments , ce qui permet à la fonction d'accepter un nombre arbitraire d'arguments. À l’intérieur de la fonction, une boucle for est utilisée pour parcourir les arguments transmis à la fonction. La boucle parcourt la variable arg, qui représente chaque argument tour à tour, et l'imprime sur la console à l'aide du imprimer() fonction.
Python3
def> python_def_keyword(>*>args):> >for> arg>in> args:> >print>(arg)> python_def_keyword(>1>,>2>,>3>)> python_def_keyword(>'apple'>,>'banana'>,>'cherry'>,>'date'>)> python_def_keyword(>True>,>False>,>True>,>False>,>True>)> |
>
>Sortir
1 2 3 apple banana cherry date True False True False True>
Exemple de mot-clé Python def avec **kwargs
Il s'agit d'un programme Python qui définit une fonction appelée python_def_keyword() en utilisant le mot-clé def. La fonction utilise le paramètre spécial **kwargs , ce qui permet à la fonction d'accepter un nombre arbitraire d'arguments de mots-clés.
À l’intérieur de la fonction, une boucle for est utilisée pour parcourir les paires clé-valeur transmises à la fonction. La boucle parcourt le kwargs dictionnaire utilisant le Méthode éléments() , qui renvoie une séquence de tuples (clé, valeur). Pour chaque tuple, la boucle décompresse les variables clé et valeur et les imprime sur la console à l'aide du imprimer() formatage des fonctions et des chaînes.
Python3
def> python_def_keyword(>*>*>kwargs):> >for> key, value>in> kwargs.items():> >print>(f>'{key}: {value}'>)> python_def_keyword(name>=>'Alice'>,> >age>=>25>, city>=>'New York'>)> python_def_keyword(country>=>'Canada'>,> >language>=>'French'>, population>=>38000000>)> python_def_keyword(color>=>'blue'>,> >shape>=>'square'>, size>=>'large'>, material>=>'wood'>)> |
>
>Sortir
name: Alice age: 25 city: New York country: Canada language: French population: 38000000 color: blue shape: square size: large material: wood>
Passer une fonction comme argument
C'est un Python programme qui définit une fonction appelée appliquer_fonction() en utilisant le mot-clé def. La fonction prend deux paramètres : func, qui est une fonction, et arg, qui est un argument à passer à func. La fonction renvoie ensuite le résultat de l'appel de func avec arg. Le programme définit également une autre fonction appelée square en utilisant le mot-clé def. Cette fonction prend un seul paramètre x et renvoie le carré de x.
Après avoir défini ces fonctions, le programme appelle la fonction apply_function avec square comme argument func et 5 comme argument arg. Cela signifie que la fonction carrée sera appelée avec 5 comme argument et que son résultat sera renvoyé par appliquer_fonction() .
Python3
def> apply_function(func, arg):> >return> func(arg)> def> square(x):> >return> x>*>*> 2> result>=> apply_function(square,>5>)> print>(result)> |
>
>Sortir
25>
Exemple de mot-clé Python def avec la classe
Dans cet exemple, nous définissons un python_def_mot-clé classe avec un __chaleur__() méthode qui prend deux arguments (nom et âge) et initialise deux variables d'instance (self. name et self. age). Nous définissons alors un dis bonjour() méthode qui imprime un message d'accueil avec le nom et l'âge de la personne. Nous créons une instance du python_def_mot-clé classe appelée python_def_keyword1 avec le nom de John et âgé de 30 ans. Nous appelons alors le dis bonjour() méthode sur le python_def_keyword1 exemple.
Python3
class> python_def_keyword:> >def> __init__(>self>, name, age):> >self>.name>=> name> >self>.age>=> age> > >def> say_hello(>self>):> >print>(f>'Hello, my name is {self.name} '> +> >f>'and I am {self.age} years old.'>)> python_def_keyword1>=> python_def_keyword(>'John'>,>30>)> python_def_keyword1.say_hello()> |
>
>Sortir
Hello, my name is John and I am 30 years old.>
Foire aux questions (FQA)
1. Comment utiliser def en Python ?
Le
def>Le mot-clé en Python est utilisé pour définir des fonctions. Nous commençons pardef>, suivi du nom de la fonction et de tous les paramètres entre parenthèses. Le corps de la fonction, en retrait ci-dessous, contient le code à exécuter. En option, nous pouvons utiliser lereturn>instruction pour renvoyer une valeur lorsque la fonction est appelée. Cette structure nous permet de créer des blocs de code réutilisables et organisés.
2. Quel est le but dudef>mot-clé en Python ?
Le
def>Le mot-clé en Python est utilisé pour définir des fonctions. Il vous permet de créer des blocs de code réutilisables avec un nom spécifique, rendant votre code modulaire, organisé et plus facile à maintenir.
3. Une fonction Python peut-elle avoir plusieurs instructions return ?
Oui, une fonction Python peut avoir plusieurs
return>déclarations. Cependant, une fois parreturn>L'instruction est exécutée, la fonction se termine et le code suivant n'est pas exécuté. Chaquereturn>L'instruction peut fournir différents résultats en fonction des conditions au sein de la fonction.