Accueil
Mes tutoriels sur la programmation
Vous pouvez me contacter via Facebook (questions, critiques constructives) : page Facebook relative à mon site
Sachez que, sans le savoir, vous avez déjà utilisé de nombreuses fonctions natives de Python : print(), len(), type(), list(), etc.
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).
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 :
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.
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 = 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).
>>> 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).
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 :
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.
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é.
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.
Revenons sur la création de fonctions personnelles.
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".
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, en effet, utiliser un type de données qui vous est encore inconnu : les tuples.
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".
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().
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" ...
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.
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