Tutoriel Python - sommaire

Les fonctions natives et personnelles en Python

Vous avez déjà utilisé de nombreuses fonctions natives de Python : print(), len(), type(), list(), etc.

Les fonctions natives et mots clés

Ci-desssous tableau de toutes les fonctions natives ou internes ("built-in functions" en anglais) :

Ces fonctions sont toujours disponibles car stockées dans le module de base de Python.
Ci-dessous une série de commandes pour vous familiariser avec les plus importantes de ces fonctions.
À saisir dans la console Python : >>> 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 >>> chaine_num ="15.5" >>> int(float(chaine_num)) 15 >>> >>> pow(10,5) 100000 >>> round(17.89,1) 17.9 >>> abs(-10) 10 >>> machaine ="bonjour" >>> max(machaine) 'u' >>> min(machaine) 'b'

Ces fonctions sont appelées aussi génériques car elles peuvent s'appliquer à différents types de données (à la différence des méthodes de classe qui sont spécifiques à un objet de cette 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 numérique) : convertit une chaine en flottant à condition bien sûr que cette chaine ait un format numérique (suite de chiffres avec un point éventuel en guise de séparateur décimal). La fonction float() fait la même chose.

Il n'est pas interdit d'utiliser un nom de fonction native pour nommer une donnée. >>> min=[5,4,5] >>> min [5, 4, 5] >>> print=['bonjour', 'aurevoir'] >>> print ['bonjour', 'aurevoir']

J'ai nommé les données de type "list" : min & print La compréhension du code va s'en ressentir fortement. Donc cette pratique est à proscrire !

Les mots clés (ou mots réservés) en Python

Ne confondez pas les fonctions natives avec les mots clés.
La liste des mots clés peut être affichée dans la console : >>> help("keywords") Here is a list of the Python keywords. Enter any keyword to get more help. False break for not None class from or True continue global pass __peg_parser__ def if raise and del import return as elif in try assert else is while async except lambda with await finally nonlocal yield

Vous n'avez pas le droit d'utiliser un mot clé pour définir un identifiant (nom de variable simple, de fonction, de liste, ...). >>> in = [5,4,3,2] ... SyntaxError: invalid syntax >>> del = (5,4,3) ... SyntaxError: invalid syntax

On ne peut pas nommer une liste, un tuple avec un mot clé tel "in" ou "del".

Le mot clé "del"

del est un mot clé qui fonctionne comme une fonction. >>> liste =list(range(2,10)) >>> liste [2, 3, 4, 5, 6, 7, 8, 9] >>> del(liste[0]) >>> liste [3, 4, 5, 6, 7, 8, 9] >>> del(liste) >>> liste ... NameError: name 'liste' is not defined

J'ai supprimé le premier élément de la liste puis toute la liste avec le mot clé del donc la demande d'affichage de cette liste retourne un message d'erreur.

À propos de la fonction print()

La fonction native la plus importante est print() ; elle permet d'afficher les résultats des traitements. L'emploi de print() est facultatif en mode interactif mais incontournable en mode programmé.
Commandes à saisir dans la console : >>> 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

Les pièges à éviter :
• 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

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 une paire d'accolades (notation "moustache").

Attention après une instruction print() il y a par défaut 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 complémentaires au module de base (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.

Première solution

C'est un peu fastidieux et pourtant je n'ai demandé que trois valeurs de 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 !).

Écrire une fonction

Une fonction pour un informaticien est une routine qui peut être appelée N fois, avec à chaque fois passage éventuel d'une valeur (ou plusieurs).
Cette routine effectue un traitement à partir des arguments saisis et retourne éventuellement une ou plusieurs valeurs.

Vous avez déjà utilisé des fonctions natives de Python : len(), type(), list(), print(), range(), ...
Vous savez que lorsque vous faites appel à une fonction native il faut lui passer des arguments.

Par exemple : range([start],stop,[step]) avec start: 1er terme ; stop : dernier terme de la suite ; step : le pas.
Seul n2 est obligatoire, les autres paramètres sont facultatifs (d'où l'indication entre crochets).

Concernant une fonction proposée par Python il suffit de l'appeler.
Concernant une fonction personnelle il faut la définir d'abord pour pouvoir l'appeler ensuite.

Une fonction personnelle en Python doit être écrite sur au moins sur deux lignes :
• une ligne pour la nommer et indiquer les paramètres
• 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.

Il y a une autre solution : écrire la fonction sur une seule ligne. C'est possible ; voir le chapitre 12 où je reviens sur les fonctions personnelles.

Commentaire de la fonction

def f(x) :  : cette fonction perso est nommée "f" avec passage d'un seul 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é.

Utilisation de ma fonction

Maintenant je peux appeler N fois ma fonction "f" :
Syntaxe pour appeler une fonction : nomFonction(argument) >>> f(-10) 105 >>> f(-5) 30 >>> f(0) 5 >>> f(5) 30 >>> f(10) 105 >>> y5 = f(10)

Je connais désormais cinq couples (x,y) donc je peux tracer la parabole dans un repère cartésien.
Je peux stocker dans une variable la valeur retournée par la fonction : la variable "y5" contient 105.

D'autres 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.
Rien n'interdit d'appeler une fonction native dans une fonction perso. >>> 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 perso 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 division_entiere(dividende,diviseur): ... return dividende//diviseur, dividende%diviseur ... >>> division_entiere(13,3) (4, 1) >>> quotient,reste =division_entiere(15,7) >>> quotient 2 >>> reste 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.
J'utilise dans cette fonction les opérateurs % & //.
Pour le deuxième appel de cette fonction j'ai deux variables devant le signe "=". Donc le quotient est affecté à "quotient" et le reste à "reste".

Fonctions basiques

Vous pouvez créer des fonctions qui n'exige aucun argument lors de leur appel et/ou ne retournent aucune valeur au programme principal.

L'instruction return est facultative dans une fonction

Ci-dessous je vous propose une fonction qui permet d'afficher une table de multiplication.
Le nombre de données produites est trop important pour être retournées par la fonction. Celle-ci se contente d'afficher les données sous forme d'un tableau grâce à une boucle FOR.
Donc si vous appelez cette fonction dans le cadre d'un script, à l'occasion de son appel elle ne retournera rien à la routine principale. >>> def table(nombre,ligne): ... for i in range(1,ligne+1): ... print(f" {i} * {nombre} = {i * nombre}") ... >>> table(9,10) 1 * 9 = 9 2 * 9 = 18 3 * 9 = 27 4 * 9 = 36 5 * 9 = 45 6 * 9 = 54 7 * 9 = 63 8 * 9 = 72 9 * 9 = 81 10 * 9 = 90

Cette fonction nommée "table" comprend une boucle.
Appel de la fonction : j'ai tapé table(9,10) ce qui signifie que je demande l'affichage de la table par 9 et les dix premières lignes (9*1 à 9*10).
Si je tape table(5,20) j'affiche la table par 5 et les 20 premières lignes (jusqu'à 9 *20 = 180).

Fonction sans paramètre

Il est possible de définir une fonction sans passage de paramètre. >>> def instant_present(): ... import time ... return time.localtime() ... >>> instant_present() time.struct_time(tm_year=2024, tm_mon=1, tm_mday=3, tm_hour=12, tm_min=7, tm_sec=28, tm_wday=2, tm_yday=3, tm_isdst=0) >>>

L'instant présent (date et heure) est retourné par la fonction "instant_present" avec moultes détails : année, rang du mois, rang du jour, heure, minutes et secondes.

J'ai définis une fonction "instant_present" sans passage de paramètre. Donc lorsque je l'appelle je n'ai aucun argument à saisir entre la paire de parenthèses.
Même si il n'y a aucun argument à saisir il faut quand même taper la paire de parenthèses lors de l'appel.

Pour comprendre le code de cette fonction, lisez le chapitre 9.

Fonction sans paramètre et sans valeur retournée

La fonction "date_courante" n'exige aucun argument lors de son appel et se contente d'afficher la date du jour.

Fonction avec un nombre variable de paramètres

Je reviens sur les fonctions au chapitre 12. Dans ce chapitre j'évoque entre autres la possibilité de créer ce genre de fonction.
Fonctions - approfondissements

Fonctions dans les modules

Il ne faut pas confondre vitesse et précipitation ; avant de vous lancer dans la création d'une fonction personnelle complexe, vous devez vous documenter sur les fonctions proposées par Python (qui ne résument pas aux fonctions natives).

En plus des fonctions natives (celles dans le module de base), Python proposent des fonctions dans différents modules. Pour utiliser ces fonctions, il faut donc activer le module en question ; "l'importer" dans le jargon Python.

Problématique : je veux calculer la racine carré de 25. Je sais qu'il existe une fonction de Python qui fait ce travail : sqrt(). >>> sqrt(25) ... 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é donc elle n'est pas encore disponible.

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 cette fonction sqrt().

J'utilise deux autres fonctions du module "math" :
• la fonction ceil() qui arrondit à l'entier supérieur
• la fonction floor() qui arrondit à l'entier inférieur

Toutes les fonctions du module math

Il suffit de taper dir(math) pour obtenir la liste des fonctions proposées par ce module.
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" et une autre nommée "gcd"

Dans le module math certaines fonctions qui font double emploi avec des fonctions génériques. Citons :
• 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 * : 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 lancer dans la création d'une fonction reposant sur un algorithme complexe, recherchez sur la "toile" pour savoir si elle n'existe pas en tant que fonction générique ou dans un module.
Supposons que vous deviez calculer le plus grand commun diviseur de plusieurs nombres. Il suffit de saisir dans un moteur de recherche : python + plus grand commun diviseur
Le site "koor.fr" vous indique que la fonction se nomme "gcd" et est dans le module "math". Il est précisé aussi que cette fonction est récente : depuis Python 3.5

Utilisation de cette fonction "math.gcd" : >>> import math >>> math.gcd(14,35) 7 >>> math.gcd(60,50,40,30) 10

Il s'agit d'une fonction qui admet un nombre variable de paramètres (voir chapitre 12).

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

Fonctions "built-in" manipulées ci-dessous :
• 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(chaine numérique) : permet de convertir en flottant une chaine (au format numérique)

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

Ma fonction perso division_entiere() présentée dans ce chapitre, était donc inutile puisque la fonction générique divmod fait la même chose ...