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 natives ou internes ("built-in functions" en anglais)de Python :

Ces fonctions sont toujours disponibles !
Il faut savoir manipuler ces fonctions. Ci-dessous une série de commmandes pour vous familiariser avec les plus importantes de ces fonctions.
Essayez ces commandes ! >>> 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'

Ces fonctions sont dites aussi génériques car elles peuvent s'appliquer à différents types de données à la différence des méthodes de classe ...
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 : >>> a = 6 >>> type(a) <class 'int'> >>> print ("le contenu de a est " , a) le contenu de a est 6 >>> print("le contenu de a est " + a) Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: can only concatenate str (not "int") to str >>> print("le contenu de a est " +str(a)) le contenu de a est 6 >>> print(f"le contenu de a est {a}") le contenu de a est 6 >>> b = 8 >>> print(f"la valeur de a est {a} et celle de b est {b}") la valeur de a est 6 et celle de b est 8

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 72 fonctions natives.
Sachez cependant que des modules (tels le module math) proposent aussi de nombreuses fonctions.

Soit la fonction (mathématique) y = x² + 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 terme !).

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.

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 : >>> def f(x) : ... return x**2+5 File "<stdin>", line 2 return x**2+5 IndentationError: expected an indented block

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 d'instructions 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 la deuxième ligne 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). Cette fonction est 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 à un 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 = x² + 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 = rayon² * 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.

Fonction retournant plusieurs valeurs

Et si on veut 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 ?
Oui une fonction peut retourner plusieurs valeurs.
Observez attentivement l'exemple ci-dessous : >>> def div_entiere(a,b): ... return a//b,a%b ... >>> div_entiere(13,3) (4, 1) >>>

En effet 13 = 4 * 3 + 1

Cette fonction retourne sous forme d'un tuple le quotient et le reste de la division euclidienne (ou division entière).
Notez aussi que cette fonction perso comprend deux paramètres : dividende et diviseur.
La notion de tuple sera approfondie plus tard.

A vous de jouer !
Creéz la fonction nommée "cercle" qui calcule la surface et la circonfère d'un cercle à partir du rayon.

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(). >>> sqrt(25) Traceback (most recent call last): File "<stdin>", line 1, in <module> NameError: name 'sqrt' is not defined

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'a pas été importé ...

Solution : >>> from math import * >>> sqrt(9) 3.0 >>> sqrt(25) 5.0 >>> x= 3.3333333 >>> ceil(x) 4 >>> floor(x) 3

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().

la fonction ceil() qui arrondit à l'entier supérieur
la fonction floor() qui arrondit à l'entier inférieur

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. J'aurais l'occasion d'y revenir ...
Il y a aussi une fonction nommée "factorial" ...

math

trunc() qui équivaut à int()
fabs() qui équivaut à abs()
fsum() qui équivaut à sum()

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

from random import * : importation de la totalité du module random.

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 en tant que fonction générique ou dans un module.
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'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 ?

Compléments sur les fonctions génériques de Python

Il y a 72 fonctions internes.
Certaines sont très utiles en mathématiques. Aussi faut-il les évoquer. >>> ord('a') 97 >>> chr(97) 'a' >>> bin(64) '0b1000000' >>> oct(64) '0o100' >>> hex(64) '0x40' >>> hex(192) '0xc0' >>> divmod(10,3) (3, 1) >>> x = 3.5e+3 >>> float(x) 3500.0 >>> y =float("10000.55") >>> y 10000.55

ord(caractère) : donne le code ascii du caractère
chr(entier) : donne la lettre correspondant au code ascii
bin(entier en base 10) : retourne l'équivalent en base 2
oct(entier en base 10) : retourne l'équivalent en base 8
hex(entier en base 16) : retourne l'équivalent en base 12
divmod(dividende, diviseur) : retourne le quotient et le reste de la division entière sous forme d'un tuple
float() : permet de convertir en flottant une chaine (au format numérique) ou un nombre exprimé en notation scientifique

Attention pour les fonctions bin(),oct(), hex() les deux premièrs caractères de la réponse précisent la base : "0b" ou "0o" ou "0x".

Donc la fonction perso division_entiere() était totalement inutile (sauf sur un plan pédagogique) puisque la fonction générique divmod fait la même chose ...

Traduction

Tutoriel Python - sommaire

Tutoriel Python - recherche

L'auteur : Patrick Darcheville