Accueil
Mes tutoriels sur la programmation

Tutoriel Python - sommaire


Vous pouvez me contacter via Facebook (questions, critiques constructives) : page Facebook relative à mon site

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 :

>>> 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

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.

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

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

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.

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 ?