Name: Python Introduction au calcul numérique
Rating: 4.5 (2 reviews)

Nombres et opérations

Les données d’un programme de calcul écrit avec Python sont des nombres entiers, des nombres décimaux ou des fractions.

1. Entiers et décimaux

Les résultats des calculs effectués avec des nombres entiers peuvent avoir un grand nombre de chiffres. Ceux qui sont effectués avec des nombres décimaux sont limités à 16 chiffres en tout. On voit ci-dessous les calculs de 10¹⁰⁰, de 23⁴⁵, de 4,56⁹ et de 7896,795367×67345,2782.

>>>1000000000000000000000000000000000000000000000000000000000000000 
0000000000000000000000000000000000000 
>>>7167183174968973473783815297819021689989265591150878511679965123 
0841339877765150252188079784691427704832 
>>> 852478.7931300849 
>>> 531811880.8790861

Pour écrire un nombre tel que 10,75, il ne faut pas utiliser la virgule, mais le point décimal à la manière anglo-saxonne. On peut également utiliser l’écriture scientifique et écrire par exemple 1.85e+34.

2. Les variables numériques

Une variable numérique associe toujours un nombre à un nom. Les noms autorisés sont les lettres de l’alphabet et les chiffres mais aussi des mots complets : a, A, b, B, x, x1, y, y0, aa, a1, b2, longueur, largeur. Bien que le choix des noms soit assez large, il faut tout de même respecter quelques règles :

Un nom doit toujours commencer par une lettre.
Les lettres accentuées, les cédilles, les espaces et les caractères spéciaux tels que $, %, # ou encore @ sont interdits.
Les lettres majuscules et les lettres minuscules sont considérées comme des caractères différents.
Un nom de variable ne peut pas être l’un des mots réservés du langage Python.

3. L’opérateur d’affectation...

Représentation des nombres

Dans un programme de calcul, on entre les données numériques sous forme décimale. Pour effectuer les calculs, Python traduit toutes les données en base 2, mais revient à la forme décimale pour afficher les résultats. Ceux-ci sont donc arrondis dans presque tous les cas.

1. Historique

Dans le cadre de la numération décimale, on écrit les nombres entiers et les nombres à virgule avec 10 chiffres, mais le système de numération binaire permet de les écrire avec 2 chiffres seulement, 0 et 1. On peut distinguer trois étapes dans l’utilisation de la numération binaire.

Au XVII^e siècle, Leibniz (1646-1716) a été un précurseur puisqu’il a employé l’écriture binaire pour effectuer des calculs. Il a d’ailleurs publié un exposé sur ses méthodes en 1703.

Longtemps après lui, en 1847, le mathématicien et logicien britannique Georges Boole (1815-1864) a proposé une approche nouvelle de la logique, à la fois symbolique et mathématique, pour analyser des propositions à l’aide d’une algèbre binaire, l’algèbre booléenne, qui n’accepte que deux valeurs numériques : 1 pour vrai et 0 pour faux.

En 1937, le mathématicien américain Claude Shannon (1916-2001) a démontré qu’il était possible de concevoir des circuits électriques capables de réaliser des opérations logiques et arithmétiques. Il n’existe que deux états pour de tels circuits, ouvert ou fermé. Ces deux états sont représentés respectivement par 0 ou par 1, chacun de ces chiffres représentant une information de 1 bit (de l’anglais binary digit, soit « chiffre binaire »)....

Fonctions disponibles dans Python

Certaines fonctions numériques sont directement accessibles dans Python, mais d’autres sont contenues dans le module « math » où il faut aller les chercher pour les importer dans le programme en cours d’écriture.

1. Les fonctions usuelles

Dès qu’on lance Python, on dispose d’un certain nombre de fonctions numériques préprogrammées que montre le tableau qui suit.

Fonction	Utilité	Exemples
abs(x)	donne la valeur absolue du nombre x	abs(-5)=5 abs(4.32)=4.32
int(x)	donne la partie entière du nombre x	int(4.5)=4 int(-3.6)=-3
max(x,y,z)	donne le plus grand des nombres indiqués (au moins 2)	max(4,6,7,10)=10
min(x,y,z)	donne le plus petit des nombres indiqués (au moins 2)	min(4,6,7,10)=4
round(x)	donne l’entier le plus proche du nombre x	round(2.4)=2, round(2.6)=3
round(x,n)	donne le nombre ayant n décimales le plus proche du nombre x	round(11.87,1)=11.9

2. Les fonctions numériques du module « math »

D’autres fonctions numériques sont disponibles dans le module « math ». Pour les utiliser dans un programme, il faut d’abord ouvrir le module en écrivant la ligne from math import* au début du programme. Le tableau qui suit donne la liste des principales fonctions présentes dans le module « math ».

Fonction	Résultat
pi	renvoie 3.141592653589793 comme valeur de π
floor(x)	plus grand entier inférieur à x
sqrt(x)	racine carrée du nombre positif x
cos(x)	cosinus de l’angle x exprimé en radians
sin(x)	sinus de l’angle x exprimé en radians
tan(x)	tangente de l’angle x exprimé en radians
acos(x)	angle (exprimé en radians) dont le cosinus est égal à x
asin(x)	angle (exprimé en radians) dont le sinus...

La récursivité des fonctions

Python est un langage de programmation récursif. Cela signifie que, dans ce langage de programmation, la définition d’une fonction peut faire appel à cette définition. On dit alors que la fonction s’appelle elle-même.

1. Les factorielles

Si n est un entier naturel supérieur à 1, on appelle factorielle n et on note n! le nombre entier obtenu en multipliant n par tous les entiers qui le précèdent, 0 et 1 exceptés. Ainsi, 4!=4×3×2×l=24 et 8!=8×7×6×5×4×3×2×l=40 320. Pour n=0 et n=1, on pose 0!=1!=1. On peut observer que le nombre n! devient rapidement très grand puisque, par exemple, 10!=3 628 800.

Pour calculer n! on peut écrire un programme itératif, mais aussi un programme qui utilise ce qu’on appelle la récursivité. Voici d’abord le programme itératif dans lequel on utilise la formule n!=n×(n-1)×(n-2)×…×2×1.

# Calcul itératif de n ! 
def factorielle(n) : 
    f=1 
    for i in range(1,n+1) : 
        f=f*i 
    return f 
# Utilisation de la fonction 
n=eval(input("Quelle est la valeur de l'entier n ;")) 
print("factorielle ",n, "=", factorielle(n))

Voici maintenant le programme récursif dans lequel la fonction fact est utilisée pour se définir elle-même. En effet, pour n supérieur à 1, on a n!=n×(n-1)!.

# Calcul récursif de n! 
def fact(n): 
    if n==0: 
       return (1) 
    else : ...

Nombres, opérations et fonctions dans Python