Les fonctions natives et personnelles en Python
Sachez que, sans le savoir, vous avez déjà utilisé de nombreuses fonctions natives de Python : print(), len(), type(), list(), etc.
Les fonctions natives
Ci-desssous tableau de toutes les fonctions dites natives de Python :
Il faut savoir manipuler ces fonctions. Ci-dessous une série de commmandes pour vous familiariser avec les plus importantes de ces fonctions.
Essayez ce code !
>>> maliste =[7,3,5,1,9]
>>> sorted(maliste)
[1, 3, 5, 7, 9]
>>> max(maliste)
9
>>> min(maliste)
1
>>> sum(maliste)
25
>>> int(15.5)
15
>>> eval("15.5")
15.5
>>> pow(10,5)
100000
>>> round(17.89,1)
17.9
>>> abs(-10)
10
>>> machaine ="bonjour"
>>> max(machaine)
'u'
>>> min(machaine)
'b'
Les fonctions natives de Python sont aussi des fonctions génériques ; elles peuvent s'appliquer à différents types de données.
Ainsi je vous montre que les fonctions min() & max() peuvent avoir pour argument une liste ou une chaine.
La fonction round(nombre décimal,n) arrondit à l'entier le plus proche OU au nombre de décimales si un deuxième argument est précisé.
La fonction pow(x,n ) élève x à la puissance n
eval(chaine) : convertit une chaine en nombre à condition que cette chaine ait un format numérique (suite de chiffres avec un point
éventuel en guise de séparateur décimal).
À propos de la fonction print()
La fonction native la plus importante est certainement print() ; elle permet d'afficher les résultats des traitements.
Commandes à saisir dans la console interactive :
- Je veux vous montrer via ces commandes plusieurs choses :
- l'argument de la fonction print() peut être une concaténation, mais à condition que tous les termes soient de type string d'où l'emploi éventuel de la fonction str() qui convertit un numérique en chaine.
- lorsque vous devez afficher dans la même ligne des chaines et des numériques il est préférable d'utiliser une chaine formatée plutôt que de séparer chaque expression par une virgule (ou utiliser l'opérateur de concaténation).
Notez bien la syntaxe : print(f"le contenu de a est {a}").
Pour préciser une chaine formatée il faut insérer la lettre "f" juste après la parenthèse ouvrante et avant les guillemets.
On peut afficher dans une chaine formatée des variables à condition qu'elles soient délimitées par des accolades.
Attention après une instruction print() il y a un saut de ligne.
Mais ce saut de ligne peut être évité avec l'argument "end:". Voir exemple ci-dessous.
>>> for i in range(5): ... print(i, end="-") ... 0-1-2-3-4->>>
Pas de saut de ligne après chaque instruction print() mais affichage d'un tiret (argument du mot reservé "end").
Écrire ma première fonction en Python
Vous pouvez avoir besoin de créer vos propres fonctions si vous n'avez pas trouvé votre bonheur dans la liste des fonctions natives.
Sachez cependant que des modules (tels le module math) proposent aussi de nombreuses fonctions.
Donc avant de "réinventer la roue", consultez la documentation Python.
Soit la fonction (mathématique) y = x2 + 5 (donc une parabole)
On veut déterminer la valeur de y pour différentes valeurs de x afin de pouvoir faire une représentation graphique de cette fonction (dessiner la parabole).
Première solution
>>> x =-5 >>> print(x**2 +5) 30 >>> x=0 >>> print(x**2+5) 5 >>> x=5 >>> print(x**2 +5) 30
C'est un peu fastidieux et pourtant je n'ai demandé que trois valeurs Y (respectivement pour x =-5, 0 et 5)
Il y a une solution beaucoup plus élégante : écrire ce qu'on appelle en informatique une fonction (et oui c'est le même mot).
Solution bien meilleure : écrire une fonction ( au sens informatique du terme)
Une fonction pour un informaticien est une routine qui peut être appelée N fois, avec à chaque fois passage d'une valeur (ici ce sera la valeur de x).
La routine retourne à chaque fois une valeur (ici ce doit être la valeur de y).
Vous avez déjà utilisé des fonctions natives de Python : len(), type(), list(), print(), range(), ...
Vous savez qu'il faut en général saisir quelque chose entre les parenthèses : un ou plusieurs arguments.
Par exemple : range(n1,n2,pas) avec n1: 1er terme ; n2 : dernier terme exclu.
- Attention une fonction Python doit être écrite au moins sur deux lignes :
- une ligne pour la définition de la fonction
- N lignes pour la description de la fonction (ce qu'elle fait)
Je tape donc dans la console :
La console me dit qu'il y a une erreur de syntaxe : une indentation non respectée.
Dans beaucoup de langages un bloc d'instructions doit être entre accolades ; dans Python le bloc doit être indenté par rapport à l'instruction
qui pilote ce bloc(ici c'est la ligne avec le mot clé "def").
La solution :
La première ligne doit se terminer par " :" (début de bloc) puis vous tapez deux fois sur ENTER
Avant de saisir la deuxième ligne il faut appuyer sur la touche TAB pour créer une indentation (vous pouvez aussi appuyer 4 fois sur la touche "espace").
Je dois donc écrire dans la console :
>>> def f(x): ... return x**2 +5 ... >>>
Après avoir saisi "return ... " tapez deux fois sur ENTER. Si l'invite de commande réapparait (les trois chevrons) c'est que la syntaxe est bonne.
Commentaire de la fonction
def f(x) : : définition de la fonction (avec le mot réservé "def"); fonction nommée "f" avec passage d'un paramètre : valeur de x.
return x**2+5 : l'expression "x**2+5" est évaluée en fonction de la valeur de x saisie ; le résultat est retourné.
Emploi de la nouvelle fonction
Maintenant je peux appeler N fois ma fonction personnelle nommée "f" pour déterminer N valeurs de Y.
>>> f(-10) 105 >>> f(-5) 30 >>> f(0) 5 >>> f(5) 30 >>> f(10) 105
Je connais désormais cinq couples (x,y) donc je peux tracer la parabole dans un repère cartésien.
Nous verrons plus tard que le tracé peut être automatisé grâce à une "dépendance" (ou module) de Python.
Encore des fonctions personnelles
Revenons sur la création de fonctions personnelles.
Une parabole
Création d'une fonction personnelle basée sur l'équation : y = x2 + 10
Vous allez me dire que l'on a déjà fait.
C'est vrai mais cette fois j'emploie dans le code la fonction native pow(x,n) : élève x à la puissance n.
>>> def parabole(x): ... y=pow(x,2)+10 ... return y ... >>> parabole(-10) 110 >>> parabole(0) 10 >>> parabole(10) 110
pow(x,2) élève à la puissance 2 le contenu de la variable x.
Ma fonction se nomme "parabole".
Le bloc d'instructions de cette fonction comprend deux lignes, toutes deux doivent être indentées par rapport à la ligne "def ...".
Aire d'un cercle ?
La surface d'un cercle = rayon2 * 3.14
Je dois donc écrire dans l'interpréteur :
>>> def aire_cercle(rayon): ... aire = rayon **2 * 3.14 ... return aire ... >>> aire_cercle(10) 314.0 >>> aire_cercle(20) 1256.0
Donc si le rayon est 10 cm alors la surface est 314 cm2
Si le rayon est 20 m alors la surface est 1256 m2
Et si on souhaitait qu'une seule fonction calcule à partir du rayon, l'aire mais aussi la circonférence du cercle et retourne donc
les deux résultats. Est-ce possible avec Python ?
La réponse est OUI mais patientez un peu ; il faut alors utiliser un type de données qui vous est encore inconnu : les tuples.
Tout cela pour rien !
Je ferme l'interpréteur puis je l'ouvre à nouveau. La fenêtre est vide !
J'ai travaillé dur mais pour rien car toutes mes fonctions personnelles ont disparu !
Nous allons devoir changer d'interface : utiliser l'éditeur IDLE à la place de l'interpréteur, afin de sauvegarder notre travail.
En d'autres termes, nous allons passer du mode "commandes" au mode "programmé".
Fonctions dans les autres modules
En plus des fonctions natives (fonctions dans le module de base), Python proposent des fonctions dans différents modules.
Pour disposer de ces fonctions, il faut donc activer les modules en question.
Thème : je veux calculer la racine carré de 25. Je sais qu'il existe une fonction native de Python qui fait ce travail : sqrt().
l'interpréteur me dit que la fonction sqrt() n'est pas définie ...
En effet cette fonction existe bien mais elle fait partie du module math, module qui n'est pas activé par défaut.
Solution :
>>> from math import * >>> sqrt(9) 3.0 >>> sqrt(25) 5.0 >>> x= 3.3333333 >>> ceil(x) 4 >>> floor(x) 3 >>> round(x,2) 3.33
Pour accéder à toutes les fonctions du module math il suffit de taper la commande from math import *
from math import * : importation de la totalité du module math
Désormais l'interpréteur comprend une commande basée sur la méthode sqrt().
- J'utilise trois autres fonctions du module "math" :
- la fonction ceil() arrondit à l'entier supérieur
- la fonction floor() arrondit à l'entier inférieur
- la fonction round() arrondit au nombre de décimales précisées dans le deuxième paramètre
Toutes les fonctions du module
tapez la commande dir(math) :
>>> dir(math) ['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'comb', 'copysign', 'cos', 'cosh', 'degrees', 'dist', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'isqrt', 'lcm', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'nextafter', 'perm', 'pi', 'pow', 'prod', 'radians', 'remainder', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau', 'trunc', 'ulp'] >>>
Il y a de quoi s'amuser pour un mathématicien ...
Sans être fort en math, vous devinez qu'il y a des fonctions de trigonométrie.
Il y a aussi une fonction nommée "factorial" ...
Le module random
Il existe un autre module qu'il faut souvent utiliser : random.
En anglais “random” signifie “le hasard”. Ce module propose des fonctions pour générer un réel, un entier de façon aléatoire, etc.
Donc si vous voulez programmer des jeux simulant le hasard, ce module est incontournable.
Commandes à saisir dans l'interpéteur :
>>> from random import * >>> x =random() >>> y=random() >>> print (x, ' ' , y) 0.5130495117445398 0.17314597535114962 >>> liste1 =[1,3,5,7,9,11] >>> choice(liste1) 11 >>> choice(liste1) 1 >>> liste2= ['Pierre', 'Paul','Jacques', 'Henri'] >>> choice(liste2) 'Jacques' >>> choice(liste2) 'Paul' >>> randint(1,100) 24
Commentaires :
from random import * : importation de la totalité du module random.
- Trois fonctions intéressantes dans ce module :
- random() : génère un réel aléatoire inférieur à 1 (pas de paramètre à saisir entre les parenthèses)
- choice(nomListe) : extrait de façon aléatoire un élément d'une liste
- randint(n1,n2) : génère de façon aléatoire un entier compris entre n1 et n2 (exclu)
Ne pas "réinventer la roue"
En résumé vous pouvez produire vos propres fonctions mais surtout "ne réinventez pas la roue". Avant de vous lancez dans la création d'une fonction
difficile recherchez sur la "toile" pour savoir si elle n'existe pas.
Je vais prendre un exemple pour illustrer mon propos. Supposons que vous deviez calculer le plus grand commun diviseur de plusieurs nombres.
Allez sur le web, vous verrez que l'algorithme correspondant est plutôt complexe.
Or la fonction existe dans Python, non pas dans le noyau de base mais dans le module math. Il suffit donc d'activer (on dit "importer")
ce module.
La solution tient en deux lignes de commandes :
>>> import math >>> math.gcd(60,50,40,30) 10
Le plus grand commun diviseur à 60,50,40,30 est le nombre 10 !
Il existe aussi dans ce module la fonction factorial() ... D'après vous à quoi sert-elle ?