Tutoriel Python - sommaire

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

Les fonctions natives et personnelles

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.
Une batterie de commandes pour vous familiariser avec la syntaxe.

>>> 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.
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é.
pow(x,n ) : x élévé à la puissance n
eval(chaine) : convertit une chaine en nombre si la chaine a un format numérique (uniquement des chiffres et un point décimal éventuel).

À propos de la fonction print()

Parmi les fonctions natives, la plus importante est certainement print() qui permet d'afficher les résultats des traitements.
Commandes à saisir dans l'intepréteur :

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 str
• un nombre peut être converti en chaine avec la fonction native str()
• 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

Une chaine formatée ("f-string") est indiquée par la lettre f juste avant l'ouverture des guillemets.
Aspect pratique : on peut afficher dans une chaine formatée des variables à condition qu'elles soient délimitées par des accolades à l'intérieur de la chaine.

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:".
Exemple :

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

Écrire ma première fonction en Python

Vous pouvez avoir besoin de créer vos propres fonctions car vous n'avez pas trouvé votre bonheur dans la liste des fonctions natives.
Sachez cependant que des modules (tels le module math) proposent aussi des 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 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 :

L'interpréteur 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 :

>>> 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 "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" de Python qui sera abordée plus tard.

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

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, en effet, 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 "programmes".

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 :
• ceil() : arrondit à l'entier supérieur
• floor() : arrondit à l'entier inférieur
• round() : au nombre de décimales précisées dans le deuxième paramètre

Toutes les fonctions du module :

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

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
• 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 voud 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 commandes :

>>> import math
>>> math.gcd(60,50,40,30)
10

J'aurais pu prendre comme exemple le calcul d'une factorielle
Rappel : f(5) = 1 * 2 * 3 * 4 * 5