Notions sur les constantes¶

Soit le code Python suivant :

1
2
3
4

z = 31
a = 42 * z + 81
z = "toto"
pi = 3.14159

Dans ce code,

31, 42, 81, "toto" ou 3.14159

sont des constantes du langage Python, Elles sont dites parfois littérales car leur façon de s’écrire dans le code permet de connaître immédiatement leur valeur, sans faire aucune opération. Par contre,

42 * z + 81

N’est PAS une constante (c’est juste une expression qui utilise des constantes). Les constantes sont des briques élémentaires (parmi d’autres) des « écritures » d’un programme.

Pour afficher une constante présente dans un code Python, on utilise la fonction print.

1
2
3
4
5
6
7
8
9

a=42
print(a)

z="toto"
print(z)
print("toto")

pi = 3.14159
print(pi)

 9
10
11
12

42
toto
toto
3.14159

• Lignes 5 ou 9 : instruction d’affichage du contenu d’une variable dont le contenu (lignes 4 ou 8) est une constante.
• Ligne 6 : on peut aussi obtenir l’affichage de la constante sans l’avoir placée dans une variable.
• Lignes 10-13 : les affichages correspondants.

Constantes flottantes¶

La présence d’un point dans une constante numérique donne à la constante le type flottant. Le point est, dans ce cas, l’équivalent de notre virgule décimale :

1

print(3.14)

2

3.14

• Ligne 1 : le nombre 3.14 est une constante flottante ; il y a des chiffres de part et d’autre du point
• Ligne 2 : l’affichage est obtenu via la fonction print.

Il est parfois possible qu’aucun chiffre ne précède ou ne suive le point :

1
2

print(1.)
print(.25)

3
4

1.0
0.25

• Ligne 1 : 1. est équivalent à 1.0
• Ligne 2 : .25 est équivalent à 0.25

Le but de ce type d’écriture est juste d’alléger la saisie du code.

En France, le séparateur décimal est une virgule. Il faut cependant toujours utiliser un point pour désigner le séparateur d’une constante flottante. Voici un exemple de comportement inattendu :

1
2

pi = 3,14
print(pi + 1)

3

TypeError: can only concatenate tuple (not "int") to tuple

• Ligne 1 : on déclare le nombre pi sous la forme 3,14 au lieu de 3.14.
• Lignes 2 : On veut ajouter 1 à pi (on devrait obtenir 4,14) mais le programme est interrompu.

On peut faire précéder une constante flottante d’un signe - ou + :

1
2

print(-3.14)
print(+3.14)

3
4

-3.14
3.14

Types de base¶

Les objets manipulées par un programme Python ont un type, au sens d’un langage de programmation : un type correspond à une catégorie d’objets (entiers, nombres réels, valeurs logiques, etc).

Voici quelques exemples de types usuels :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

print(42)
print(4 + 6)
print(-5 * 2)

print(421.5)
print(2.7 + 10)

print(421 > 42)
print(421 < 42)

print("toto")

12
13
14
15
16
17
18
19

42
10
-10
421.5
12.7
True
False
toto

• Lignes 1-3 : type entier. Les entiers peuvent être positifs comme négatifs.
• Lignes 5-6 : type flottant. Pour simplifier, il s’agit de nombres dit « à virgule », ci-dessus représentés en base 10. Le point utilisé dans le nombre représente notre virgule décimale («  flottant  » fait allusion à la notion de virgule «  flottante  »).
• Lignes 8-9 et 17-18 : type booléen. Une expression de type booléen a une valeur de vérite True ou False.
• Lignes 11 : le type chaîne. En première approximation, une chaîne représente une suite de caractères. Dans l’exemple, pour que Python reconnaisse le mot toto comme une donnée de type chaîne, on entoure le mot d’une paire de guillemets.

Connaître le type d’un objet¶

Bien que l’usage explicite des types ne soit pas dans la philosophie du langage Python, il existe une fonction built-in qui permet de connaître le type de n’importe quel objet, la fonction[[1]] type :

1
2
3
4
5

print(type(42))
print(type("toto"))
print(type(3.14))
print(type(len))
print(type([42, 20, 100]))

 6
 7
 8
 9
10

<class 'int'>
<class 'str'>
<class 'float'>
<class 'builtin_function_or_method'>
<class 'list'>

• Il faut comprendre que 42 est de type int, c’est analogue pour les autres lignes
• Tout objet a un type, par exemple la fonction len a un type, le type builtin**function**or_method

En phase d’apprentissage et dans une optique de compréhension du langage Python, il peut être utile de faire appel à la fonction type.

Constantes entières¶

Les constantes entières figurant textuellement dans un code , telles que 421, peuvent être précédées d’un signe - pour désigner un entier négatif ou d’un signe +, facultatif et en général omis :

1
2

print(-42)
print(+421)

3
4

-42
421

Toute constante entière, écrite de la façon habituelle avec des chiffres entre 0 et 9, comme 421 ou 0 est interprétée par défaut comme écrite en base 10.

Attention à ne pas placer involontairement un 0 comme premier chiffre d’une constante entière, comme on le ferait pour certaines dates (par exemple 01 dans la date 19/01/2038) sinon on obtient un message d’erreur :

1

print(042)

2
3
4
5

  File "_.py", line 1
    print(042)
            ^
SyntaxError: invalid token

Opérations mixtes entre flottants et entiers¶

Lorsqu’on effectue un ensemble d’opérations arithmétiques qui font intervenir des entiers et des flottants, le résultat est de type flottant :

1
2
3
4
5

x = 1.0
y = 42

print(x * y)
print(x - x)

6
7

42.0
0.0

• Lignes 4 et 5 : bien que les valeurs des flottants représentent des nombres entiers, le résultat est de type flottant

Variables et typage¶

Un nom de variable n’est pas associé à un type fixé

1
2
3
4

a = 2020
print(a)
a = 3.14
print(a)

5
6

2020
3.14

• Ligne 1 : l’étiquette a se réfère d’abord à un entier.
• Ligne 3 : l’étiquette a se réfère ensuite à un flottant.

Une variable n’a pas de type. Ce qui a un type est l’objet placé en mémoire et que la variable référence.

Une variable peut étiqueter un objet de n’importe quel type.

Par exemple, on peut placer une variable sur le nom d’une fonction :

1
2

p = print
p("bonjour")

3

"bonjour"

Grands entiers¶

On peut effectuer tout type d’opération arithmétique avec des entiers aussi grands qu’on le souhaite. Une opération arithmétique ne peut jamais créer d”« overflow » comme c’est le cas en C ou Java où les entiers sont codés sur un nombre prédéfini de bits.

Exemple d’usage de grands entiers :

1
2
3

a = 8596125023601452569859
b = 7012365895410232252363
print(a * b)

4

60279173948185303803365326980576772175326817

Opérations sur les nombres¶

Voici quelques opérations usuelles que l’on peut effectuer entre nombres réels (pas seulement entiers).

On peut calculer des expressions mathématiques avec des parenthèses :

1
2
3
4

print(-421)
print(2 * 10 + 15)
print((2 + 3) * (8 + 2))
print(42.1 / 10)

5
6
7
8

-421
35
50
4.21

• Lignes 4 et 8 : on effectue la division « exacte » de 42.1 par 10.

Certains calculs nécessitent le placement de parenthèses. Par exemple, en mathématiques, on écrit couramment

\(\displaystyle\frac a{bc}.\)

En Python, cela NE se traduit PAS par a / b * c mais par a /(b * c) :

1
2
3

x = 100 / 10 * 5
y = 100 / (10 * 5)
print(x, y)

4

50.0 2.0

En cas de doute dans un calcul, placer des parenthèses même s’il est possible qu’elles ne soient pas indispensables. Ainsi, la fraction

\(\displaystyle \frac{\frac{100.0}{5}}4\)

sera traduite par (100. / 5) / 4 :

1
2
3

x = (100 / 5) / 4
y =  100 / 5 / 4
print(x, y)

4

5.0 5.0

Ne pas utiliser de crochets à la place des parenthèses car les crochets ont un autre sens en Python.

Pour calculer une puissance \(x^y\), on écrit x ** y dans le code Python :

1
2
3

print(10 ** 2)
print(6.25 ** 0.5)
print(0 ** 0)

4
5
6

100
2.5
1

Les nombres \(x\) et \(y\) peuvent n’être pas des entiers.

En particulier, x ** 0.5 représente \(\sqrt x\), la racine carrée de \(x\) (lignes 2 et 5)

1
2

print(10000000000000)
print(10**13)

3
4

10000000000000
10000000000000

Élévation à la puissance¶

La façon la plus simple de calculer des puissances est d’utiliser l’opérateur ** :

1

print(10.24 ** 1.5)

2

32.768

Racine carrée¶

Comme \(\sqrt x = x^{\frac 12}=x^{0.5}\), le moyen le plus simple de calculer \(\sqrt x\) est x ** .5 :

1

print(2 ** 0.5)

2

1.4142135623730951

Il semblerait que x ** 0.5 renvoie toujours un flottant même si la valeur mathématique est un entier :

1

print(100 ** 0.5)

2

10.0

Calculs¶

Faire effectuer par Python les calculs suivants :

\(\displaystyle a=10 ^{ 2 \times 3}\quad b=\displaystyle\frac {666}{74\times 9}\quad \displaystyle c = 2 \times 3,14159 + 2,71828 + 1,4142 \times 5 \quad \displaystyle d=\frac{1}{1000^{\frac{2}{3}}}\)

Utiliser des variables¶

Quand on veut « récupérer » (autrement dit sauvegarder) le résultat d’un calcul, on le place dans une nouvelle variable :

1
2
3
4
5
6

x = 42
y = 5
z = (x * y + 5) * (x ** 2 + y **2 ) - 100
u = (z - 10000) * x

print(u)

7

15730470

• Lignes 3 : on stocke sous le nom de z le résultat d’un calcul en mémoire
• Lignes 4 : on stocke sous le nom de u le résultat d’un autre calcul
• Ligne 6 : on affiche le contenu de la variable

Une expression utilisant une variable ne modifie pas le contenu de la variable :

1
2
3

toto = 42
print(toto + 1)
print(toto)

3
4

43
42

• Ligne 2 : on ajoute 1 à la valeur de toto. Le résultat (ici 43) est affichée mais ce calcul est « perdu » puisqu’il n’est pas replacé dans une variable.
• Ligne 5 : bien qu’on ait ajouté 1 à toto, le contenu de la variable toto reste inchangé par rapport à sa valeur initiale.

Volume de la sphère¶

Le volume de la sphère est

\(V=\frac 43\pi r^3\)

Écrire en Python une formule (avec des variables) qui calcule le volume \(V\) d’une sphère de rayon \(r\). On posera pi = 3.14. Tester avec \(r = 10\).

Solution

D’abord, écrire la formule de manière purement formelle ne fonctionne pas :

v = 4/3 * pi * r**3
print(v)

NameError                                 Traceback (most recent call last)
<ipython-input-32-b6f8fcc9c76e> in <module>()
----> 1 v = 4/3 * pi * r**3
      2 print(v)

NameError: name 'pi' is not defined

Python n’est pas un outil de calcul formel.

Il faut initialiser r mais aussi \(\pi\) :

pi = 3.14

r=10
v = 4/3 * pi * r**3
print(v)

4186.666666666667

Pour tester d’autres valeurs, le plus simple est de changer r dans le code-source et de relancer l’exécution du code.