Share
En Python, vous avez peut-être rencontré des problèmes tels que file (), print (), open (), range (), etc. fonctions intégrées. C'est-à-dire des fonctions déjà fournies par le langage lui-même que vous pouvez exécuter en les référant (en les appelant). Mais, quelle est une fonction de toute façon? C’est ce que nous allons apprendre dans ce tutoriel, à la manière de Python!
Les fonctions sont composés d’un ensemble d’instructions combinées pour obtenir un résultat (réalisation d’une tâche), et sont exécutés en les appelant, à savoir par un appel de fonction. Les résultats en Python peuvent être soit la sortie d’un calcul dans la fonction, soit Aucun. Ces fonctions peuvent être soit intégré fonctions (mentionnées ci-dessus) ou défini par l'utilisateur les fonctions. Les fonctions définies dans les classes sont appelées les méthodes.
Maintenant que nous savons ce qu’on entend par fonction, voyons comment définir des fonctions en Python. Pour ce faire, nous utilisons le def instruction, qui a la syntaxe suivante:
def nom_fonction (paramètres): instruction (s) expression de retour
le paramètres dans la définition de la fonction sont facultatifs, car certaines fonctions n’exigent pas que les paramètres soient passés au moment de l’appel de la fonction. Si plus d'un paramètre est passé, les paramètres sont séparés par des virgules et sont liés à l'élément. arguments dans la fonction qui correspondent aux paramètres passés. Les instructions (corps de la fonction) sont exécutées lorsque la fonction est appelée.
le revenir instruction est une instruction facultative qui sert de point de sortie de la fonction où une expression peut être renvoyée à l'appelant ou, si aucune expression n'est identifiée, ce sera comme si une expression était renvoyée. Aucun valeur.
Passons en revue quelques exemples pour mieux comprendre l’idée de fonctions. Vous remarquerez que les fonctions nous évitent de nous répéter, car elles fournissent un bloc de réutilisable code à appeler chaque fois que nous voulons effectuer une tâche régulière que nous devrions effectuer.
Dites que nous aimerions afficher le nom de tout employé entré dans le système. Cela peut ressembler à ceci:
nom_employé = 'Abder' def nom_impression (nom): nom_impression nom_impression (nom_employé)
Comme vous pouvez le constater, si nous voulons appeler une fonction, nous identifions simplement les éléments suivants:
Si vous tapez nom_impression (nom_employé) avant la définition de la fonction, Python se plaindra comme suit:
Traceback (appel le plus récent en dernier): fichier "test.py", ligne 3, dansnom_impression (nom_employé) NameError: le nom 'nom_impression' n'est pas défini
Donc, vous devez définir la fonction avant de l'appeler.
Prenons un autre exemple. Cette fois, nous allons utiliser des listes. Supposons que nous ayons la liste suivante:
numbers_list = [1,2,3,4,5]
Disons maintenant que nous voulons insérer de nouveaux nombres en utilisant cette fonction:
numbers_list = [1,2,3,4,5] def insert_numbers (numbers_list): numbers_list.insert (5, 8) numbers_list.insert (6, 13) print 'List \ "à l'intérieur de" la fonction est:', numbers_list return insert_numbers (numbers_list) print 'List \ "outside \" la fonction est:', numbers_list
Notez que la sortie de ce script Python sera:
Liste "à l'intérieur" la fonction est: [1, 2, 3, 4, 5, 8, 13] Liste "à l'extérieur" la fonction est: [1, 2, 3, 4, 5, 8, 13]
Que pouvons-nous conclure de ceci? On peut en conclure que les paramètres sont passé par référence. C'est-à-dire que les paramètres de la fonction appelée sont les mêmes que les arguments passés (variable / identité) par l'appelant, par opposition à passé par valeur où les paramètres de la fonction appelée sont une copie des arguments passés par l'appelant.
Utilisons nos connaissances des fonctions pour construire légèrement une application plus intéressante. Construisons une calculatrice simple. Cette calculatrice permettra à l’utilisateur de saisir deux nombres et d’effectuer une addition, soustraction, multiplication, et division sur les deux chiffres.
def add (x, y): retour x + y def soustrait (x, y): retour xy def multiplier (x, y): retour x * y def division (x, y): retour x / yx = 8 y = 4 imprimer '% d +% d =% d'% (x, y, ajouter (x, y)) imprimer '% d -% d =% d'% (x, y, soustraire (x, y)) imprimer '% d *% d =% d'% (x, y, multiplier (x, y)) imprimer '% d /% d =% d'% (x, y, diviser (x, y))
Allez-y, essayez-le et voyez quelle sortie vous obtenez.
Les fonctions Lambda sont des fonctions anonymes créées par Python au moment de l'exécution à l'aide du lambda construction. Jusqu'ici, nous avons appris que les fonctions sont définies à l'aide du def déclaration. Les fonctions Lambda sont toutefois définies d'une manière différente. Prenons un exemple pour clarifier le fonctionnement des fonctions Lambda.
Disons que nous voulons écrire une fonction qui retourne le double valeur de l'argument passé. En utilisant le def déclaration, nous ferions ce qui suit:
def double (x): retour x * 2 x = 10 print double (x)
La façon Lambda d’écrire cette fonction est la suivante:
x = 10 double = lambda x: x * 2 impression double (x)
Vous pouvez utiliser Lambda de différentes manières. Consultez ce tutoriel pour plus d'informations sur les fonctions Lambda..
Comme nous pouvons le constater, les fonctions sont considérées comme une fonctionnalité importante de Python, car elles vous permettent de réutiliser du code plutôt que de réinventer la roue..
Accentsconagua