Langages et programmation

À quoi a-t-on accès lorsqu’on utilise un langage de programmation ?

Nous allons aborder chacun de ces points.

Quelques objets primitifs en Python

Le langage Python possède un grand nombre d’objets primitifs. Parmi eux, on utilisera lors des premiers chapitres :

• Les constantes entières (« Integer », int)

1
2
3
4

>>> type(3)
<type 'int'>
>>> type(-10)
<type 'int'>

• Les constantes « flottantes » (type float). Il s’agit d’une approximations des nombres non entiers¹.

1
2
3
4
5
6

>>> type(0.1)
<type 'float'>
>>> type(-2.9)
<type 'float'>
>>> type(2e3)
<type 'float'>

• Les valeurs booléennes (type bool) True et False.

1
2
3
4

>>> type(True)
<type 'bool'>
>>> type(False)
<type 'bool'>

• Les chaînes de caractères (« String », type str).

1
2
3
4
5
6

>>> type("abcd")
<type 'str'>
>>> type('abcd')
<type 'str'>
>>> type('a')
<type 'str'>

Syntaxe et évaluation d’une expression en Python

Ambigüité de l’écriture traditionnelle des expressions

En mathématique on écrit l’expression qui permet de calculer la valeur du polynôme du second degrés, pour toute valeur de la variable $x$ : $3 x^2 + 2 x + 4$. En programmation, peut-on se contenter d’utiliser la syntaxe des mathématiques ?
Si on se penche un peu plus attentivement sur l’écriture du polynôme, on remarque :

• qu’il faut savoir que $2 x$ signifie la multiplication du nombre 2 par $x$ ;

• que pour $3 x^2$ il faut d’abord élever $x$ à la puissance 2 avant de multiplier le résultat par 3 ;

• que $2 x + 4$ n’est pas 2 multiplié par le résultat du calcul de $x + 4$ ;

• que cette écriture est une écriture à deux dimensions (élévation à la puissance 2 est indiquée en augmentant l’espace depuis la ligne de base).

De même, en mathématique, on écrit :

• $a + b$ : l’opérateur $+$ est entre les deux opérandes ;

• $\sin (x)$ : la fonction est placée avant son argument ;

• $f’$ pour indiquer la fonction dérivée de la fonction $f$ (le symbole de la dérivée est placé après le nom de la fonction).

En conclusion, l’écriture mathématique traditionnelle nous parait claire car on l’utilise depuis les plus petites classes et parce qu’on a appris des règles telles que celles de la priorité des opérateurs. En informatique, la syntaxe devra être plus rigoureuse, moins ambiguë car la machine effectuera une vérification pointilleuse de tout ce qui sera écrit.

L’écriture la plus rigoureuse du polynôme est : $\left( \left( 3 \times \left( x^2 \right) \right) + \left( \left( 2 \times x \right) + 4 \right) \right)$, heureusement le langage Python a intégré la règle de priorité des opérateurs et on pourra écrire : 3 * x** 2 + 2 * x + 4.

Remarque : Les expressions en informatique ne se limitent bien évidemment pas au domaine des mathématiques.

Opérateurs arithmétiques en Python

Les opérateurs en Python se répartissent en trois catégories :

• les opérateurs arithmétiques, utilisés pour calculer des expressions ;

• les opérateurs de comparaison et les opérateurs logiques, utilisés dans l’alternative ;

• les opérateurs d’affectation, utilisés pour modifier la « valeur » d’une variable.

Dans ce chapitre nous allons nous contenter d’utiliser les opérateurs arithmétiques.

Application d’une fonction

Schéma-bloc d’une fonction

Par exemple, le schéma-bloc de la fonction « mise au carré » est le suivant :

Ce schéma indique que la fonction attend un argument (le nombre 2), effectue un traitement (élévation à la puissance 2) et retourne une valeur (le nombre 4).

Fonctions intégrées du langage Python

Le langage Python possède de nombreuses fonctions prédéfinies. Les fonctions intégrées dir et help permettent de les découvrir.

1
2
3
4
5
6
7
8
9

>>> dir()
['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__']
>>> dir('__builtins__')
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
>>> help(abs)
Help on built-in function abs in module builtins:

abs(x, /)
    Return the absolute value of the argument.

L’exemple ci-dessus pourrait laisser penser que le nombre de fonctions n’est pas aussi grand qu’annoncé. Elles sont en fait organisées au sein de modules : math, random, time qu’il faut importer au préalable pour pouvoir les utiliser.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

>>> import math
>>> dir(math)
['__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'pi', 'pow', 'radians', 'remainder', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau', 'trunc']
>>> help(math.tan)
Help on built-in function tan in module math:

tan(x, /)
    Return the tangent of x (measured in radians).
>>> import random
>>> dir(random)
['BPF', 'LOG4', 'NV_MAGICCONST', 'RECIP_BPF', 'Random', 'SG_MAGICCONST', 'SystemRandom', 'TWOPI', '_BuiltinMethodType', '_MethodType', '_Sequence', '_Set', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_acos', '_bisect', '_ceil', '_cos', '_e', '_exp', '_inst', '_itertools', '_log', '_os', '_pi', '_random', '_sha512', '_sin', '_sqrt', '_test', '_test_generator', '_urandom', '_warn', 'betavariate', 'choice', 'choices', 'expovariate', 'gammavariate', 'gauss', 'getrandbits', 'getstate', 'lognormvariate', 'normalvariate', 'paretovariate', 'randint', 'random', 'randrange', 'sample', 'seed', 'setstate', 'shuffle', 'triangular', 'uniform', 'vonmisesvariate', 'weibullvariate']
>>> help(random.random)
Help on built-in function random:

random(...) method of random.Random instance
    random() -> x in the interval [0, 1).

Remarque : On constate que pour utiliser une fonction contenue dans le module de nom module, on doit utiliser la syntaxe module.nom_de_la_fonction.

Syntaxe de l’application d’une fonction

L’appel (ou l’application) d’une fonction obéit à une syntaxe bien particulière, semblable à celle utilisée en math. Par exemple, l’appel de la fonction abs avec l’argument -3 s’écrit abs(-3).

Évaluation de l’argument d’une fonction

Il n’est pas nécessaire de fournir une constante comme argument à une fonction, on peut lui fournir une expression comme argument. Par exemple l’appel suivant abs(3 + 4 / 2 + 7 // 3) est tout à fait valide.
L’interpréteur Python procède ainsi :

1. Évaluation de l’expression 3 + 4 / 2 + 7 // 3. Le résultat est le nombre 7.0 ;
2. Appel de la fonction abs avec comme argument le nombre 7.0.

Définition d’une fonction

Malgré leur grand nombre, les fonctions prédéfinies du langage peuvent ne pas être suffisantes. Il faut alors définir soi-même une nouvelle fonction.

Type et signature d’une fonction

En mathématique, on définie la fonction $f$ qui calcule le carré d’un nombre réel de la sorte :

$$ \begin{array}{l|rcl} f: & \mathbb{R} & \longrightarrow & \mathbb{R} \cr & x & \longmapsto & f(x) \cr \end{array} $$

En informatique, on s’appuie sur cette écriture, en la précisant un peu, on dit que la fonction possède un nom, un type et une signature.

La connaissance de la signature d’une fonction est fondamentale, ce n’est pas parce qu’une fonction se nomme sum qu’elle est capable de faire la somme de deux nombres (cf. exercice 2 plus bas) ! Le type de la fonction indique quels sont les types des arguments qu’elle accepte et donne une première (mais insuffisante !) indication sur la façon de l’utiliser.

Remarque : En informatique, on aura très souvent à utiliser des fonctions plus complexes que celle présentée ici, en particulier, des fonctions à plusieurs paramètres. Sans explication supplémentaire, il vous faudra admettre qu’une fonction nommée surface qui calcule la surface d’un rectangle de côtés $a$ et $b$ a pour définition

$$ \begin{array}{l|rcl} \text{surface} : & \Bbb{R} \times \Bbb{R} \longrightarrow \Bbb{R}\cr & (a, b) \longmapsto a \times b \end{array} $$

Définition d’une fonction en Python

La syntaxe utilisée pour définir une fonction en Python est assez proche de celle des mathématiques :

1
2

def f(x: float) -> float:
	return x**2

On reconnaît tout de suite la signature de la fonction def f(x: float) -> float qui indique bien que la fonction possède un paramètre x de type float et retourne une valeur de type float. Chaque paramètre peut donc être accompagné de son type !

• Les deux points : à la fin de la ligne servent à indiquer que le bloc d’instructions qui suit la signature constitue le corps de la fonction, c’est à dire l’ensemble des étapes qui sont réalisées lorsqu’on appelle la fonction.

• L’instruction return indique à la fonction de retourner la valeur qu’elle vient de calculer.

La définition de la fonction surface définie plus haut est la suivante :

1
2

def surface(a: float, b: float) -> float:
	return a * b

Spécification d’une fonction

Il est donc indispensable d’établir un contrat entre le concepteur de la fonction et son utilisateur.

Remarque : Une spécification ne s’intéresse pas au « comment » !
L’utilisateur d’une fonction n’a pas besoin de connaître en détail toutes les étapes du traitement du problème par la fonction, il doit juste savoir quelle valeur elle retourne et comment il faut l’utiliser.

Exemple : Spécification d’une fonction qui élève au carré :

1
2

def f(x: float) -> float:
	""" Retourne le carré du nombre x passé en argument. """

En fait, la spécification est la seule contrainte qu’est tenu de respecter le concepteur d’une fonction. Il faut donc être capable de faire la distinction entre toutes les spécifications suivantes :

• Le programmeur ne s’occupe pas vraiment des conditions d’utilisation de la fonction. Il présuppose que tous les utilisateurs penseront à vérifier que l’argument est bien positif lors de l’appel de la fonction.
  Dans ce cas de figure, l’utilisateur doit faire l’effort de bien comprendre le fonctionnement de la fonction.

1
2

def racine_carree(x: float) -> float:
	""" Retourne la racine carrée du nombre x. """

• Le programmeur avertit l’utilisateur qu’il existe une bonne utilisation de la fonction (l’argument doit être positif ou nul) mais n’empêche pas l’utilisateur d’appeler la fonction avec un mauvais argument.
  Ici aussi, il incombe à l’utilisateur de bien utiliser la fonction.

1
2
3
4

  def racine_carree(x: float) -> float:
  	""" 
    Retourne la racine carrée du nombre x.
    HYPOTHÈSE : x positif ou nul. """

• Le programmeur prend en charge la bonne utilisation de la fonction.

1
2
3
4
5

def racine_carree(x: float) -> float:
	"""
	Retourne la racine carrée du nombre x si positif ou nul.
	ERREUR : x négatif.
	"""

Exercices du chapitre

1
2
3
4
5
6
7
8

>>> help(sum)
Help on built-in function sum in module builtins:

sum(iterable, /, start=0)
    Return the sum of a 'start' value (default: 0) plus an iterable of numbers
    When the iterable is empty, return the start value.
    This function is intended specifically for use with numeric values and may
    reject non-numeric types.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

>>> help(int)
Help on class int in module builtins:

class int(object)
 | int([x]) -> integer                                                   |
 | i-------------------------------------------------------------------r |
 |                                                                       |
 | Convert a number or string to an integer, or return 0 if no arguments |
 | are given.  If x is a number, return x.__int__().  For floating point |
 | numbers, this truncates towards zero.                                 |

1
2
3
4
5
6

>>> import math as m
>>> help(m.pow)
Help on built-in function pow in module math:

pow(x, y, /)
    Return x**y (x to the power of y).

1
2
3
4
5
6
7
8

>>> import math as m
>>> dir(m)
['__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'pi', 'pow', 'radians', 'remainder', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau', 'trunc']
>>> help(m.sqrt)
Help on built-in function sqrt in module math:

sqrt(x, /)
    Return the square root of x.

1
2
3
4
5
6

>>> import random as rd
>>> help(rd.randint)
Help on method randint in module random:

randint(a, b) method of random.Random instance
    Return random integer in range [a, b], including both end points.

1
2

def retire_un(n):
	return 1 - n

1
2

def retire_un(n: float) -> float:
	""" Retourne la valeur de n - 1 """

La fonction telle qu'elle est définie à la question 1 correspond-elle à cette spécification ?

1
2
3

def retire_un(n: float) -> float:
	""" Retourne la valeur de n - 1 """
	return n - 1

1
2
3
4
5
6
7
8
9

def polynomiale(a:int, b:int, c:int, d:int, x: float) -> float:
    """
    Retourne la valeur ax^3 + bx^2 + cx + d
    
    >>> polynomiale(1, 1, 1, 1, 2)
    15.0
    >>> polynomiale(1, 1, 1, 1, 3)
    40.0
    """

1
2
3
4
5
6
7
8
9

def polynomiale_carre(a:int, b:int, c:int, x: float) -> float:
    """
    Retourne la valeur ax^4 + bx^2 + c
    
    >>> polynomiale(1, 1, 1, 1, 2)
    15.0
    >>> polynomiale(1, 1, 1, 1, 3)
    40.0
    """

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

def polynomiale(a: int, b: int, c: int, d: int, x: float) -> float:
    """
    Retourne la valeur ax^3 + bx^2 + cx + d

    >>> polynomiale(1, 1, 1, 1, 2)
    15.0
    >>> polynomiale(1, 1, 1, 1, 3)
    40.0
    """
    return a * x**3 + b * x**2 + c * x + d


def polynomiale_carre(a:int, b:int, c:int, x: float) -> float:
    """
    Retourne la valeur ax^4 + bx^2 + c

    >>> polynomiale(1, 1, 1, 1, 2)
    15.0
    >>> polynomiale(1, 1, 1, 1, 3)
    40.0
    """
    return a * x**4 + b * x**2 + c

1
2
3
4

def somme(x:float, y: float, z: float) -> float:
    """
    Retourne la somme des trois nombres passés en argument.
    """

1
2
3
4

def moyenne(a: float, b: float, c: float) -> float:
    """
    Retourne la moyenne des trois nombres passés comme arguments.
    """

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

def moyenne_ponderee(x:float, y:float, z:float, a:int, b:int, c:int) -> float:
    """
    Retourne la moyenne pondérée des nombres x, y et z par les coefficients
    a, b et c.
    
    >>> moyenne_ponderee(5, 10, 15, 1, 1, 1)
    10.0
    >>> moyenne_ponderee(5, 10, 15, 1, 1, 0)
    7.5
    """

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

def somme(x:float, y: float, z: float) -> float:
    """
    Retourne la somme des trois nombres passés en argument.
    """
    return x + y + z


def moyenne(a: float, b: float, c: float) -> float:
    """
    Retourne la moyenne des trois nombres passés comme arguments.
    """
    return somme(a, b, c) / 3


def moyenne_ponderee(x:float, y:float, z:float, a:int, b:int, c:int) -> float:
    """
    Retourne la moyenne pondérée des nombres x, y et z par les coefficients
    a, b et c.
    
    >>> moyenne_ponderee(5, 10, 15, 1, 1, 1)
    10.0
    
    >>> moyenne_ponderee(5, 10, 15, 1, 1, 0)
    7.5
    """
    return somme(a * x, b * y, c * z) / somme(a, b, c)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

from math import pow, pi

def surface_rectangle(a: float, b: float) -> float:
    """ Détermine la surface du rectangle de côtés a et b. """
    return a * b


def volume_parallelepipede(a: float, b: float, h: float) -> float:
    """ Retourne le volume du parallélépipède rectangle de côtés a, b et de
    hauteur h. """
    return surface_rectangle(a, b) * h


def surface_disque(r: float) -> float:
    """ Returne la surface du disque de rayon r. """
    return pi * pow(r, 2)


def surface_couronne(r1: float, r2: float) -> float:
    """
    Retourne la surface de la couronne comprise entre les rayons r1
    et r2.
    """
    return surface_disque(r2) - surface_disque(r1)


def volume_tube(r1, r2, l) -> float:
    """ Retourne le volume de la partie pleine d'un tube de longueur l, dont
    la section est une couronne de rayon intérieur r1 et de rayon extérieur
    r2. """
    return surface_couronne(r1, r2) * l

1
2
3
4
5
6
7
8

def distance(x1: float, y1: float, x2: float, y2: float) -> float:
    """
    Retourne la distance dans le plan entre les deux points de coordonnées
    (x1, y1) et (x2, y2).
    
    >>> distance(0, 0, 1, 1)
    1.4142135623730951
    """

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

from math import pow, sqrt

def distance(x1: float, y1: float, x2: float, y2: float) -> float:
    """
    Retourne la distance dans le plan entre les deux points de 
	coordonnées (x1, y1) et (x2, y2).
    
    >>> distance(0, 0, 1, 1)
    1.4142135623730951
    """
    return sqrt(pow(x2 - x1, 2) + pow(y2 - y1, 2))

1
2
3
4
5
6
7

from random import random  
    
def tirage_entier(a: int) -> int:
    """
    Retourne un nombre entier aléatoire compris entre 1 et a (inclus).
    """
    return int(random() * a + 1)