Vous apprendrez déjà à écrire vos premières fonctions.
Et tout cela illustré avec le langage de programmation Python.
Les données
L’informatique est la science de la résolution de problèmes et du traitement des données.
Les programmes informatiques ne font que calculer et transformer des données. Ces données peuvent être très diverses :
- des nombres,
- des textes,
- du son,
- des images ...
Les données que traitent les programmes informatiques peuvent être extrêmement complexes. Mais elles se construisent toutes à partir de quelques briques de bases. Nous allons en explorer ici deux sortes :
- les nombres
- et les chaînes de caractères.
Les nombres
Les nombres sont l’une des données de base que l’on rencontre partout. À l’origine, les ordinateurs ont été créés pour effectuer des calculs. Les anglophones les désignent d’ailleurs par le mot computer ce qui se traduit littéralement par calculateur, et l’expression computer science est l’équivalent de notre mot informatique.
Les nombres entiers
Les plus simples des nombres sont les nombres entiers. Ils s’écrivent comme d’habitude en base 10 en utilisant les chiffres de 0 à 9, précédés éventuellement d’un signe + ou -. (Mais on verra dans une séquence prochaine qu’on peut les écrire autrement.)
Ils peuvent être négatifs.
Contrairement à certains autres langages de programmation (comme C ou Java par exemple), en Python il n’y aucune limite au nombre de chiffres d’un nombre entier.
Voici à titre d’exemple l’expression permettant de calculer 2100. On obtient un nombre à 31 chiffres.
>>> 2 ** 100
1267650600228229401496703205376
Les nombres flottants
Les nombres flottants, ou plus précisément à virgule flottante, sont des nombres non entiers comprenant une partie décimale après la virgule qui est marquée par un point conformément à l’usage anglo-saxon.
Lorsque la partie entière d’un nombre flottant devient trop grande (en valeur absolue), ou lorsqu’elle est nulle et que la première décimale non nulle est située loin après la virgule, ce nombre est écrit sous la forme m×10e avec 1≤|m|<10 et e∈Z. Le nombre m est appelé mantisse et l’entier e exposant.
>>> 125.**8
5.960464477539062e+16
>>> 125.**-8
1.6777216e-17
On peut d’ailleurs toujours écrire les nombres flottants sous cette forme :
À propos de la division
En Python3, l’opérateur de division donne toujours en résultat un nombre flottant. C’est évident quand la division “ne tombe pas juste” :
>>> 18 / 7
2.5714285714285716
mais c’est aussi le cas lorsqu’elle tombe juste :
Si on souhaite effectuer une division entière ou euclidienne, c’est-à-dire déterminer le quotient q et le reste r de la division d’un nombre entier a par un nombre entier b,
avec 0≤r<b, il faut utiliser les opérateurs // et %.
>>> 18 // 7
2
>>> 18 % 7
4
Table des opérateurs arithmétiques (listés par priorité croissante)
| Opérateurs | Significations |
|---|
| + et - | addition et soustraction |
| * et / // et % | multiplication et division quotient et reste |
| - | négation (chgt de signe) |
| ** | exponentiation |
Tout calcul effectué sur des nombres entiers est garanti exact. En revanche, les calculs effectués sur des flottants peuvent être entâchés d’erreurs (de troncatures et d’arrondis par exemple).
En voici un exemple :
>>> 1.1 + 2.2 - 3.3
4.440892098500626e-16
Le calcul aurait dû donner 0, mais on obtient un nombre un peu plus grand : 4×10−16.
La différence peut sembler insignifiante, mais combinée à d’autres calculs, elle peut devenir très significative.
Les chaînes de caractères
Après les nombres, les chaînes de caractères sont des données très fréquemment manipulées par les programmes informatiques.
Une chaîne de caractères est une suite de caractères mis les uns après les autres, un caractère pouvant être une lettre (majuscule ou minuscule), un chiffre, un symbole de ponctuation, une espace, et bien d’autres choses encore.
En Python, les chaînes de caractères littérales sont écrites en les entourant soit de deux simples quotes (') ou deux doubles quotes (").
>>> "Timoleon"
'Timoleon'
>>> 'Timoleon'
'Timoleon'
Aucune limitation n’existe sur le nombre de caractères que contient une chaîne. Ce nombre est appelé la longueur de la chaîne.
En Python, la fonction len donne la longueur d’une chaîne.
Une chaîne de carcatères peut ne contenir aucun caractère. On parle alors de la chaîne vide. Littéralement, la chaîne vide s’écrit avec deux quotes ou deux doubles quotes.
Le choix des délimiteurs (' ou ") est en général indifférent. Mais si une chaîne de caractères doit contenir l’un de ces deux symboles, il faut choisir l’autre comme délimiteur.
>>> "Le symbole ' est une simple quote"
"Le symbole ' est une simple quote"
>>> 'Le symbole " est une double quote'
'Le symbole " est une double quote'
Citons pour l’instant une seule opération sur les chaînes de carcatères : la concaténation. Cette opération consiste à construire une chaîne de caractères à partir de deux chaînes données en les mettant bout à bout.
En Python, l’opération de concaténation est désignée par l’opérateur +.
>>> "Cette phrase contient les deux symboles ' " + 'et " !'
'Cette phrase contient les deux symboles \' et " !'
Note
Remarquez l’utilisation de la contre-barre \ devant la quote ' dans la réponse.
Nous étudierons les chaînes de caractères de manière un peu plus approfondie dans une séquence prochaine.
Type de données
Vous connaissez maintenant trois types de données : les nombres entiers, les nombres flottants et les chaînes de caractères. Il y en a encore bien d’autres que vous découvrirez par la suite.
Il est important lorsqu’on programme d’avoir présent à l’esprit les types des données qu’on manipule, car certaines opérations sont possibles pour certains types mais pas pour d’autre.
Par exemple la soustraction peut s’effectuer sur les nombres (entiers ou flottants) mais pas sur les chaînes de caractères.
>>> 'Timoleon' - 'leon'
Traceback (most recent call last):
File "<pyshell#26>", line 1, in <module>
'Timoleon' - 'leon'
TypeError: unsupported operand type(s) for -: 'str' and 'str'
Le message d’erreur provoqué par la commande ci-dessus indique bien TypeError: unsupported operand type(s) for -: 'str' and 'str', ce qui signifie que l’opérateur - ne s’applique pas sur des chaînes de caractères (désignées dans ce message par str).
En Python la fonction type donne le type de la valeur qu’on lui donne. En voici quelques exemples.
>>> type(100)
<class 'int'>
La réponse int indique que 100 est de type int, c’est-à-dire entier (integer en anglais).
>>> type(100.)
<class 'float'>
- est de type float, c’est-à-dire flottant.
>>> type('Timoleon')
<class 'str'>
Enfin, les chaînes de caractères sont de type str (string en anglais).
Expressions et instructions
Une expression est une combinaison de valeurs littérales ou de variables (voir plus bas) combinées avec des opérateurs en vue de produire une nouvelle valeur.
Les expressions arithmétiques sont des expressions portant sur les nombres et leurs valeurs sont des nombres.
Une instruction est une expression qui n’a pas de valeur à proprement parler. Une instruction est un ordre que l’on donne à l’ordinateur.
Une instruction fréquente est celle d’impression de la valeur d’une expression. L’impression s’obtient avec la fonction print.
Voici l’instruction d’impression de la chaîne de caractères "Timoleon".
>>> print("Timoleon")
Timoleon
Note
Notez l’absence de délimiteur autour du mot Timoleon qui a été imprimé. Cela distingue la réponse obtenue plus haut pour la valeur de l’expression “Timoleon”.
D’ailleurs remarquons que
>>> type(print("Timoleon"))
Timoleon
<class 'NoneType'>
ce qui signifie que l’expression print("Timoleon") n’a pas de valeur (NoneType).
On peut utiliser la fonction print pour imprimer la valeur d’expressions composées.
En voici une illustration pour une expression arithmétique.
>>> print((12 + 3) * 5)
75
On peut donner à la fonction print plusieurs expressions à imprimer. On le fait tout simplement en séparant ces expressions par des virgules. Cette fonction imprime alors la valeur de ces expressions sur une même ligne dans l’ordre où elles ont été écrites.
>>> print("(12 + 3) * 5 = ",(12 + 3) * 5)
(12 + 3) * 5 = 75
Depuis la version 3 de Python, print est devenu une fonction, et les parenthèses sont donc obligatoires autour des expressions à imprimer. Ces parenthèses n’étaient pas obligatoires dans les versions précédentes du langage. Il se peut donc que vous trouviez dans vos lectures des programmes où ces parenthèses sont absentes.
Variables
Une variable est un nom qu’on associe à une valeur.
En voici un exemple :
Cette instruction associe la valeur 3,141592 au nom pi. Le symbole utilisé par Python pour marquer cette association est le symbole = qui n’a donc pas la signification de l’égalité comme c’est le cas par exemple en mathématiques.
Les instructions consistant à attribuer une valeur à une variable sont appelées affectation.
Maintenant que nous avons défini la variable pi, nous pouvons l’utiliser dans des expressions pour effectuer des calculs. Profitons-en pour calculer la circonférence et l’aire d’un cercle de rayon 2,5m.
>>> r = 2.5
>>> circ = 2 * pi * r
>>> aire = pi * r * r
>>> print('Circonférence = ',circ,'m. Aire = ',aire,'m^2.')
Circonférence = 15.70796 m. Aire = 19.63495 m^2.
Voici un usage des variables pour mener à bien le calcul des racines d’un polynôme du second degré ax2+bx+c.
Prenons le cas du polynôme x2+x−6, c’est-à-dire a=1, b=1 et c=−6.
>>> a = 1
>>> b = 1
>>> c = -6
Calculons le discriminant Δ=b2−4∗a∗c.
>>> delta = b*b - 4*a*c
>>> delta
25
Le discriminant est positif donc le polynôme admet deux racines réelles distinctes x1 et x2 déterminées par les formules
x1=−b+Δ−−√2a et x2=−b−Δ−−√2a.
Nous avons besoin de la fonction racine carrée qui n’est pas fournie par le langage de base Python. Il faut l’importer du module math qui est un module contenant toutes les fonctions mathématiques usuelles. Cette fonction se nomme sqrt (pensez à square root).
>>> from math import sqrt
>>> x1 = (-b + sqrt(delta)) / (2*a)
>>> x2 = (-b - sqrt(delta)) / (2*a)
>>> x1
2.0
>>> x2
-3.0
Affectation
Une variable peut changer de valeurs au cours de l’exécution d’un programme. Pour changer la valeur d’une variable, il suffit d’utiliser l’instruction d’affectation identique à celle utilisée ci-dessus.
Voici une séquence d’instructions dans laquelle une variable a prend successivement trois valeurs.
>>> a = 1
>>> print ('Première valeur : ',a)
Première valeur : 1
>>> a = 2
>>> print ('Deuxième valeur : ',a)
Deuxième valeur : 2
>>> a = a + 1
>>> print ('Troisième valeur : ',a)
Troisième valeur : 3
Identificateurs
En informatique, les noms donnés aux variables sont souvent désignés sous le terme identificateur. Dans les exemples précédents, pi, r, circ, aire, a, b, c, delta, x1et x2 sont des identificateurs de variables.
Chaque langage de programmation établit des règles déterminant quels sont les identificateurs acceptés. Python n’échappe pas à la règle.
En Python les identificateurs peuvent contenir des lettres, des chiffres et le blanc souligné (_). Ils ne peuvent pas contenir d’espaces, ni d’autres symboles comme + et - entre autres. Les identificateurs ne peuvent pas débuter par un chiffre. Ils peuvent être de longueur arbitraire.
Ils sont sensibles à la casse : aire et Aire sont des identificateurs distincts pour Python.
>>> Aire
Traceback (most recent call last)
File "<pyshell#39>", line 1, in <module>
Aire
NameError: name 'Aire' is not defined
Le message d’erreur NameError signale que l’identificateur Aire n’est pas défini.
Mots-clés
Certains mots ne sont pas autorisés comme identificateurs de variables : ce sont les mots-clés ou mots réservés du langage Python.
À titre d’exemple, supposons que nous soyions occupés à écrire un programme de jeu de cartes, et nous voulons définir une variable nommée as à laquelle nous attribuons la valeur 1.
>>> as = 1
SyntaxError: invalid syntax
Nous remarquons un message qui indique une erreur de syntaxe (SyntaxError: invalid syntax). Cela provient de la tentative d’utilisation du mot as comme identificateur de variable, ce qui n’est pas autorisé étant donné que ce mot est l’un des 33 mots-clés du langage.
Liste des mots clés du langage Python (dans la version 3).
| and | as | assert | break | class | continue | def |
| del | elif | else | except | False | finally | for |
| from | global | if | import | in | is | lambda |
| None | nonlocal | not | or | pass | raise | return |
| True | try | while | with | yield | | |
Fonctions
Écrire une nouvelle fonction
Programmer c’est utiliser des bibliothèques de fonctions toutes prêtes (comme la fonction sqrt du module math). Mais c’est surtout créer de nouvelles fonctions.
Une première fonction
Voici comment en Python on peut écrire la fonction qui à un nombre réel x associe le nombre x2+1−−−−−√. Appelons f cette fonction.
def f(x):
return sqrt(x**2 + 1)
Analyse du code de cette fonction nous pouvons distinguer deux parties :
- la première ligne commençant par le mot-clé def qu’on appelle en-tête,
- et tout le reste (ici une seule ligne) qu’on appelle le corps.
Description de l’en-tête d’une fonction
- Il débute toujours par le mot-clé def.
- Ce mot est suivi du nom que l’on donne à la fonction (ici f), ce nom suivant les mêmes règles que les identificateurs de variables.
- Vient ensuite le nom d’un paramètre formel (ici x). Ce paramètre sert à désigner la valeur qui sera fournie à la fonction lorsque nous l’utiliserons. Dans le cas présent, le paramètre x sert à désigner n’importe quel nombre.
- Enfin l’en-tête se termine par un : qui marque le début d’un bloc d’instructions qui suit et que l’on nomme corps de la fonction.
Description du corps de la fonction
- Il est ici constitué d’une seule ligne.
- Cette ligne débute par le mot-clé return. Ce mot signale ce que la fonction doit fournir comme résultat, ou dit autrement quelle est la valeur qu’elle doit renvoyer.
- Après le mot return vient l’expression qui décrit la valeur que doit renvoyer la fonction. Ici cette expression est sqrt(x\*\*2 + 1) qui est bien la transcription en Python de x2+1−−−−−√. L’identificateur x qui figure dans cette expression correspond au paramètre de la fonction. Lorsque cette fonction sera utilisée avec une valeur numérique, cette valeur viendra prendre la place de x.
Note
À noter le décalage vers la droite du corps de la fonction par rapport à l’en-tête. Il est obligatoire en Python. Ce décalage se nomme indentation. Vous découvrirez petit à petit l’importance de l’indentation en Python.
Lorsqu’une fonction a été définie, on peut l’utiliser. On dit qu’on fait appel à la fonction en lui transmettant une valeur en argument.
Voici quelques exemples d’appels à cette fonction :
>>> f(1)
1.4142135623730951
On obtient bien une valeur approchée de 12+1−−−−−√=2–√.
Les arguments passés en paramètre à une fonction peuvent être n’importe quelle expression dont la valeur est du bon type, autrement dit pour notre exemple n’importe quelle expression numérique.
Voici un deuxième appel à notre fonction avec une expression numérique cette fois :
>>> f(3**2)
9.055385138137417
encore un autre :
>>> f(sqrt(8))
3.0000000000000004
et encore un :
>>> f(f(1))
1.7320508075688774
Et on peut aussi utiliser un appel à une fonction au sein d’une expression (sous réserve de compatibilité de type) :
>>> 3 * f(1)
4.242640687119286
Telle qu’elle a été conçue, notre fonction f ne peut pas être appelée avec des arguments non numériques.
>>> f('Timoleon')
Traceback (most recent call last):
File "<pyshell#48>", line 1, in <module>
f('tim')
File "<pyshell#42>", line 2, in f
return sqrt(x**2 + 1)
TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'int'
Une exception TypeError: unsupported operand type(s) for \*\* or pow(): 'str' and 'int' a été déclenchée à cause de la tentative d’élever une chaîne de caractères ('Timoleon') à la puissance 2, ce qui n’a pas de sens.
Il faut donc impérativement que tout appel à f s’effectue avec des argument de types numériques int ou float.
Une variante de cette fonction
Il ne faut pas confondre une fonction qui renvoie une valeur et une fonction qui imprime une valeur.
La fonction f que nous avons écrite plus haut renvoie des valeurs numériques (dans ce cas une valeur approchée de x2+1−−−−−√). Mais nous aurions très bien pu écrire une fonction qui imprime une valeur, comme la fonction f2 définie ci-dessous.
def f2(x):
print (sqrt(x**2 + 1))
Note
Notez bien l’absence du mot-clé
return qui indique que cette fonction ne renvoie pas de valeur. Elle se contente d’en imprimer une.
En faisant appel à cette fonction,
>>> f2(1)
1.4142135623730951
>>> f2(sqrt(8))
3.0000000000000004
en apparence rien ne distingue les fonctions f et f2. Mais ce n’est qu’une apparence trompeuse.
Observons la commande suivante :
>>> 3 * f2(1)
1.4142135623730951
Traceback (most recent call last):
File "<pyshell#53>", line 1, in <module>
3 * f2(1)
TypeError: unsupported operand type(s) for *: 'int' and 'NoneType'
Le message d’erreur (TypeError: unsupported operand type(s) for *: 'int' and 'NoneType') indique une incompatibilité de type pour l’opérateur de multiplication (*) que l’on fait agir sur une valeur de type int (3) et une valeur de type NoneType.
En effet le type de l’expression f2(1) est le même que celui de la valeur du print. Et nous l’avons vu plus haut, le type d’un print est bien NoneType.
>>> type(f2(1))
1.4142135623730951
<class 'NoneType'>
Lorsqu’on a à programmer une fonction, il faut donc bien réfléchir à l’usage qu’on en fera. Si on veut utiliser la fonction pour la composer avec d’autres on préfèrera une fonction qui renvoie une valeur à l’équivalente qui imprime cette valeur.
Une fonction un peu plus complexe
Le nombre de paramètres d’une fonction n’est pas limité à 1. Une fonction peut avoir plusieurs paramètres.
À titre d’exemple, voici la réalisation d’une fonction nommée plus_grande_racine qui renvoie la plus grande des deux racines d’un polynôme du second degré ax2+bx+c dont on passe les coefficients en paramètre. Cette plus grande racine est évidemment égale à
max(−b+Δ−−√2a,−b−Δ−−√2a),
avec:math:‘Δ=b2−4ac‘,pourvuque:math:‘Δ≥0‘.
def plus_grande_racine (a,b,c):
delta = b*b - 4*a*c
x1 = (-b + sqrt(delta)) / (2*a)
x2 = (-b - sqrt(delta)) / (2*a)
return max(x1,x2)
Analyse du code de cette fonction
- On distingue l’en-tête (première ligne) et le corps (quatre lignes suivantes).
- L’en-tête donne le nom de la fonction plus_grande_racine, suivi du nom des trois paramètres séparés par des virgules, le tout entre parenthèses. Il se termine par un :.
- La première ligne du corps définit une variable nommée delta à laquelle on attribue la valeur de l’expression b*b - 4*a*c.
- La deuxième ligne définit une variable nommée x1 qui se voit attribuer la valeur d’une première racine.
- La troisième ligne définit une autre variable ayant pour valeur la seconde racine.
- Enfin la dernière ligne est cette qui détermine la valeur qui sera renvoyée.
On peut donc remarquer que
- une fonction peut avoir plusieurs paramètres,
- son code peut être développé en plusieurs instructions,
- elle peut utiliser des variables.
Il faut noter aussi le décalage vers la droite de chacune des quatres lignes du corps qui suivent l’en-tête qu’on appelle indentation comme signalé déjà plus haut. Cette indentation est obligatoire en Python.
Utilisons cette fonction pour déterminer la plus grande racine réelle du polynôme x2+x−6 qui admet les racines 2 et -3 comme on l’a vu plus haut.
>>> plus_grande_racine (1,1,-6)
2.0
Note
Les variables delta, x1 et x2 utilisées dans le code de la fonction n’existent que dans le corps de cette fonction. Ce sont des variables locales à la fonction.
En voici une mise en évidence. Si on calcule la plus grande racine du polynôme x2−x−1 on va trouver que
- Δ=5,
- x1=1+5√2≈1,618,
- x2=1−5√2≈−0,618,
et donc la plus grande racine est donc x1, ce que donne bien notre fonction :
>>> plus_grande_racine (1,-1,-1)
1.618033988749895
Mais si on demande quelles sont les valeurs des trois variables delta, x1 et x2
>>> print (delta, x1, x2)
25 2.0 -3.0
on observe d’autres valeurs. Ce sont celles qui ont été calculées un peu plus haut.
Contraintes d’utilisation d’une fonction
Les paramètres que l’on passe à une fonction peuvent être soumis à des contraintes à respecter si l’on veut que le calcul se déroule sans incident.
Par exemple, vous savez que la racine carrée d’un nombre réel négatif n’est pas définie. Que se passe-t-il si on fournit un nombre négatif à la fonction sqrt en Python ?
>>> sqrt(-1)
Traceback (most recent call last):
File "<pyshell#64>", line 1, in <module>
sqrt(-1)
ValueError: math domain error
Nous obtenons une exception ValueError: math domain error, qui une fois déclenchée interrompt la poursuite du calcul.
Par conséquent, les nombres que l’on passe à la fonction sqrt doivent être positifs ou nuls. C’est une contrainte d’utilisation (CU) de cette fonction.
Évidemment, la fonction plus_grande_racine que nous avons écrite hérite de la contrainte de la fonction sqrt puisqu’elle l’utilise.
Tout appel à cette fonction avec les coefficients d’un polynôme dont de discriminant est négatif déclenchera la même erreur. C’est ainsi le cas pour le polynôme x2+x+1.
>>> plus_grande_racine (1,1,1)
Traceback (most recent call last):
File "<pyshell#65>", line 1, in <module>
plus_grande_racine (1,1,1)
File "<pyshell#61>", line 3, in plus_grande_racine
x1 = (-b + sqrt(delta)) / (2*a)
ValueError: math domain error
Cette fonction possède encore une autre contrainte d’utilisation :
>>> plus_grande_racine (0,1,1)
Traceback (most recent call last):
File "<pyshell#66>", line 1, in <module>
plus_grande_racine (0,1,1)
File "<pyshell#61>", line 3, in plus_grande_racine
x1 = (-b + sqrt(delta)) / (2*a)
ZeroDivisionError: float division by zero
Cette fois-ci, c’est l’exception ZeroDivisionError: float division by zero qui est déclenchée. En effet, le paramètre a de la fonction s’est vu attribué la valeur 0 à l’appel, et le calcul des racines nécessite la division par 2*a qui est nul.
En conséquence, une utilisation normale de la fonction nécessite le respect de deux contraintes :
- a≠0,
- b2−4ac≥0.
Conclusion
Dans cette leçon vous avez découvert
- trois types de données de base : les entiers (int), les flottants (float) et les chaînes de caractères (str),
- la possibilité de combiner ces données à l’aide d’opérateurs et de fonctions pour former des expressions plus ou moins complexes,
- les variables qui permettent de mémoriser des valeurs en les nommant à l’aide d’identificateurs,
- l’écriture de vos propres fonctions.
Source :Licence 1ère année) - fil - Université Lille 1
