Nombres, opérations et fonctions dans Python

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 :

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

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 »)....

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.

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

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