Mise en route

Chapitre 1
Mise en route
Nous supposerons ici que Python est déjà installé et fonctionnel. En complément de ce polycopié, on pourra
également consulter le tutorial officiel de Python (en anglais) :
https ://docs.python.org/3/tutorial/
Dans la suite de ce document, nous indiquerons les commandes Python et le résultat donné par l’interprète.
Les commandes venant après les chevrons >>> sont les commandes tapées par l’utilisateur. Le résultat donné
par Python se lit alors sur la ligne suivante. Lorsque Python n’a rien à renvoyer, la ligne est omise.
1.1
1.1.1
Variables et types simples
Premiers pas
On peut utiliser Python comme une calculatrice :
>>> 6 ∗ 7
42
Les entiers en Python ne sont pas limités. Calculons 25 à la puissance 20 :
>>> 25 ∗ ∗20
9094947017729282379150390625
Les opérateurs usuels sur les entiers sont : +, −, ∗. La précédence entre ces opérateurs est standard : ∗ est
prioritaire sur + ou −.
>>> 2 + 3 ∗ 2
8
La division entière se note // et le reste de la division euclidienne se note % :
>>> 14//3
4
>>> 14%3
2
On peut également manipuler des nombres à virgule (nombres flottants). Ici, la simple présence d’un unique
flottant dans une expression indique à Python de tout effectuer avec des nombres à virgules, donc réels.
>>> 3. + 12
15.0
Notez qu’on obtient uniquement une valeur approchée. Notamment, un rationnel comme 1/33 n’existe qu’en
tant qu’approximation :
1
1.1. VARIABLES ET TYPES SIMPLES
CHAPITRE 1. MISE EN ROUTE
>>> 1.0/33.0
0.030303030303030304
(Ici le 4 à la fin illustre bien le problème de l’approximation d’un réel par un flottant).
1.1.2
Le module ”math” de la bibliothèque standart
√
Les fonctions mathématiques usuelles telles que : x 7→ x ,sin, cos... sont disponibles dans la bibliothèque
standart de Python : ce ne sont pas des fonctions qui existent dans le ”noyau” de Python, mais elles ont déjà été
programmées ; pour pouvoir les utiliser, il faut les charger depuis le module math de la bibliothèque standart
avec l’instruction import sinon Python se vexe :
>>> sin(2.5)
Traceback (most recent call last) :
File ”<stdin>”, line 1, in <module>
NameError : name ’sin’ is not defined
sin n’est en effet pas défini par défaut.
>>> from math import sin
>>> sin(2.5)
0.59847214410395655
après importation de la fonction sin du module math, on peut l’utiliser.
Pour importer toutes les fonctions du module math :
>>> from math import ∗
>>> cos(2.5)
−0.8011436155469337
On pourra trouver notamment dans le module math :
— Les fonctions usuelles : sin, cos, exp, floor (partie entière), ceil (partie entière supérieure), abs (valeur absolue), factorial (la factorielle), log (logarithme népérien), log(.,p) (logarithme en base p), acos (arccos),
asin (arcsin), atan (arctan), atan2 (détermine un argument de x+iy), cosh (cos hyperbolique), sinh (sin
hyperbolique), tanh (tangente hyperbolique).
— Les constantes usuelles de mathématiques : pi , 1j (le ”i” des complexes), e (base de l’exponentielle).
Remarque :
Pour faire des calculs exacts sur les fractions, on pourra importer le module fractions.
>>> from fractions import Fraction
>>>Fraction(1,33)+Fraction(1,17)
Fraction(50,561)
1.1.3
Entiers et flottant
Les valeurs manipulées par Python sont cataloguées selon différents types. Le type int désigne une valeur
entière (en anglais : integer ) alors que le type float désigne une valeur réelle (raccourci de l’anglais floating
point number : nombre à virgule flottante).
Notez la différence entre les entiers et les flottants. 42 est un entier :
>>> type(42)
<type ’int’>
Mais 42.0 est un flottant :
2
CHAPITRE 1. MISE EN ROUTE
1.2. DÉFINITION DE VARIABLES
>>> type(42.0)
<type ’float’>
Il est possible de convertir un entier en flottant à l’aide de l’opérateur float :
>>> float(42)
42.0
Et dans l’autre sens avec l’opérateur int qui tronque la partie décimale :
>>> int(42.4)
42
>>> int(−42.4)
−42
Pour plus de contrôle sur la conversion, on pourra utiliser les fonctions de troncature et d’arrondi : math.floor
pour la partie entière inférieure, math.ceil pour la partie entière supérieure et math.round pour un arrondi
(après importation du module math ).
>>> floor(42.4)
42.0
>>>math.ceil(42.4)
43.0
>>> round(42.4)
42.0
>>> round(42.6)
43.0
>>> int(round(42.6))
43
On pourra retrouver la définition de ces fonctions dans l’aide intégrée à Python. On y accède à l’aide de la
fonction help :
>>> help(math.ceil)
Help on built-in function ceil in module math :
ceil(...)
ceil(x)
Return the ceiling of x as a float.
This is the smallest integral value >= x.
Python convertit automatiquement les entiers en flottants quand cela est pertinent. Ainsi :
>>> from math import sqrt
>>> sqrt(2)
1.4142135623730951
donne la même chose que sqrt(2.0).
1.2
1.2.1
Définition de variables
Affectation
Généralités
Le symbole d’affectation pour donner une valeur à une variable est le symbole = :
>>> x = 4
3
1.2. DÉFINITION DE VARIABLES
CHAPITRE 1. MISE EN ROUTE
Python ne répond rien : nos entrées précédentes étaient des expressions, qu’il a interprétées comme des
questions et il y a répondu. Ici, nous lui avons donné une instruction, il exécute l’ordre et se contente d’affirmer
qu’il est prêt en nous gratifiant de nouveau d’un >>>. On peut alors lui demander la valeur de x :
>>> x
4
L’instruction x = 4 crée une nouvelle variable appelée x et mémorise dans cette variable la valeur 4. On dit
que la variable x est initialisée à la valeur 4. Par la suite, chaque appel de la variable x s’évaluera en remplaçant
x par 4.
Le nom d’une variable ne doit pas contenir d’espace. Il ne peut être composé uniquement de lettres non
accentués, de chiffres et du caractère souligné .
On peut aussi affecter plusieurs variables simultanément :
>>> a, b = 17, 42
>>> a
17
>>> b
42
L’affectation se fait en parallèle, ce qui est bien pratique pour échanger le contenu de deux variables :
>>> b, a = a, b
>>> a
42
>>> b
17
1.2.2
Incrémentation
Pour ajouter une valeur (par exemple 3) à une variable, on peut faire comme dans les langages de programmation classiques :
>>> x = 0
>>> x = x + 3
>>> x
3
Mais on peut aussi utiliser + = (c’est la façon de faire idiomatique en Python) :
>>> x+ = 3
>>> x
6
On dispose de même de ∗ = , − = , / = et // = :
>>> x∗ = 5
>>> x
30
>>> x− = 7
>>> x
23
4
CHAPITRE 1. MISE EN ROUTE
1.2.3
1.2. DÉFINITION DE VARIABLES
Notion d’expression
A droite d’une affectation, il doit y avoir une expression c’est-à-dire :
— Une constante (de type int,float,ou autres...)
— Une variable déjà affectée
— Un appel de fonction dont les paramètres sont eux-mêmes une expression.
Une expression peut se représenter par un arbre de calcul dont chaque noeud est un appel de fonctions et
dont les ramifications sont des variables ou des arbres (dits sous-arbres) :
Exemple : Soit l’affection : a =exp(x)+cos(3 ∗ y)
On peut construire l’arbre :
+
exp
cos
x
*
3
y
On constate que les opérations + et ∗ sont considérées comme des fonctions. ”exp(x)+cos(3 ∗ y)” n’est une
expression que si x et y sont eux-mêmes des expressions, c’est-à-dire des variables initialisées.
Il ne faut donc pas confondre une expression (qui est donc un arbre de calcul) et son évaluation (qui est le
résultat de ce calcul).
>>> from math import exp , cos
>>> a =exp(x)+cos(3 ∗ y)
Traceback (most recent call last) :
NameError : name ’y’ is not defined
>>> y = 2
>>> x = 0
>>> a =exp(x)+cos(3 ∗ y)
>>> a
1.9601702866503659
Si par la suite, on modifie la valeur de x ou y, la valeur de a ne sera pas modifiée.
>>> from math import exp , cos
>>> y = 2
>>> x = 0
>>> a =exp(x)+cos(3 ∗ y)
>>> a
1.9601702866503659
>>> y = 0
>>> a
1.9601702866503659
1.2.4
Autres types simples
Les booléens
Les booléens, ou valeurs de vérité, peuvent prendre deux valeurs : True ou False. Les opérateurs de comparaison (< , > , <= , >=) permettent de comparer deux nombres :
5
1.2. DÉFINITION DE VARIABLES
CHAPITRE 1. MISE EN ROUTE
>>> 17 < 42
True
>>> 17 > 42
False
On dispose également de l’opérateur == pour tester l’égalité (attention : ce n’est pas =, qui est le symbole
d’affectation) et ! = pour tester si deux nombres sont différents (imaginer le point d’exclamation comme une
barre verticale barrant le symbole d’égalité) :
>>> 42 == 42
True
>>> 42! = 42
False
>>> 17 == 42
False
>>> 17! = 42
True
On peut calculer la conjonction ou la disjonction de deux booléens avec les opérateurs ” and ” et ” or ” :
>>> 17 > 42 or 3 == 3
True
>>> 17 < 42 and 3 != 3
False
>>> 17 < 42 and 3 == 3
True
La négation logique d’un booléen b se note not(b) :
>>> not(17 == 42)
True
On peut convertir un booléen en entier :
>>> int(True)
1
>>> int(False)
0
On peut également convertir un entier en un booléen. Tout entier non nul est converti en True et 0 est
converti en False.
>>> bool(42)
True
>>> bool(0)
False
Plus généralement, n’importe quelle valeur nulle (0 pour les entiers, 0.0 pour les flottants, et, pour les types
chaı̂nes de caractères et liste qu’on verra plus loin, une chaı̂ne vide, une liste vide) sera considérée comme le
booléen False et les autres valeurs comme True.
Il faut faire très attention aux tests d’égalité avec des valeurs approchées.
>>> from math import sqrt
>>> a=sqrt(3)
>>> (sqrt(a))**2==a
False
Ainsi Python ne donne pas le bon résultat. En effet, Python fait des erreurs d’arrondi, à cause de la
représentation décimale d’un réel qui est nécessairement une approximation :
6
CHAPITRE 1. MISE EN ROUTE
1.3. ENTRÉE AU CLAVIER ET AFFICHAGE À L’ÉCRAN
>>> (sqrt(a)) ∗ ∗2
1.7320508075668777
>>> a
1.7320508075668772
Ici, Python commet une erreur sur la 16-ième décimale .
Les chaı̂nes de caractères
Python peut manipuler des chaı̂nes de caractères. Une chaı̂ne de caractères peut se noter entre apostrophes
simples ou apostrophes doubles, indifféremment :
>>> qui = ’Python’
L’opération principale sur les chaı̂nes de caractères est la concaténation, notée avec le symbole + :
>>> ’bonjour ’ + qui
’bonjour Python’
On peut convertir un nombre en chaı̂ne de caractères :
>>> str(42)
’42’
>>> str(2.5)
’2.5’
Et réciproquement :
>>> int(’42’)
42
>>> float(’2.5’)
2.5
En revanche la concaténation ne donne pas lieu à conversion implicite :
>>> n = 10
>>> ’numero’ + n
Traceback (most recent call last) :
File ”<stdin>”, line 1, in <module>
TypeError : cannot concatenate ’str’ and ’int’ objects
>>> ’numero ’ + str(n)
’numero 10’
1.3
1.3.1
Entrée au clavier et affichage à l’écran
Instruction ”input(’message’)”
L’instruction input(’message’) affiche à l’écran ”message” et attend que l’utilisateur valide par ”Entrée” une
réponse au clavier. Attention la réponse est, par défaut, comprise comme chaı̂ne de caractère :
>>> n = input(’entrez un entier :’)
entrez un entier : 21
>>> n
’21’
>>>type(n)
str
7
1.3. ENTRÉE AU CLAVIER ET AFFICHAGE À L’ÉCRAN
CHAPITRE 1. MISE EN ROUTE
Il faudra donc convertir (surtout en version Python3) la réponse reçue par input dans le type désiré (souvent
int ou float).
Remarque : Avec Anaconda, la conversion sera automatique (cf. importation des modules scientifiques).
Pour obtenir directement une chaı̂ne de caractères, on pourra utiliser la commande : raw input().
1.3.2
Instruction ”print message”
La fonction print permet d’afficher des informations à l’écran. Il s’agit souvent de messages d’informations .
>>>print(’a’,11,’b’,202,’c’,333) ; print( ’d’ , 1/3,’e’, 1/7 ) ;
a 11 b 202 c 333
d 0.3333333333333333 e 0.14285714285714285
Cependant , pour améliorer l’affichage, on pourra écrire :
>>> print(’a’ , 1 , ’b’, 2 , sep=’*’)
a*1*b*2
>>> print(’a’ , 2 , ’b’,3 ,sep =’− + −’) ; print(’c’ , 5 , ’d’) ;
a− + −2− + − b− + − 3
c5d
>>> print(’a’,2,’b’,3,end=”) ;print(’c’,’d’,5) ;
a 2 b 3c d 5
On peut utiliser la méthode format (qui s’applique sur un objet string). Cela permet de créer des chaı̂nes de
caractères en remplaçant certains champs (entre accolades) par des valeurs passées en argument de la fonction
format ainsi que l’illustre l’exemple suivant :
>>> n = input(’entrez un entier : ’) ;
print ’{ }ˆ2={ }’.format(n,n**2)
On peut aussi formater l’affichage d’un flottant x, en précisant le nombre de décimale, la notation scientifique, la longueur de la chaı̂ne à afficher...
1. ’{ :g}’.format(x) choisit le format le plus approprié .
2. ’{ :.nf}’.format(x) affiche x avec n décimales .
3. ’{ :.3e}’.format(x) affiche x en notation scientifique .
4. ’{0 :20.3f}’.format(x) précise la longueur de chaı̂ne affichée .
5. ’{0 :+.3f} ;{1 :-.3f}’.format(x,−x) affiche toujours le signe de x.
>>> x = 327.7689432
>>> ’{ :.4f}’.format(x)
’327.7689’
>>> ’{ :.5e}’.format(x)
’3.27769e+02’
>>> ’{0 :4.3f}’.format(x)
’327.769’
>>> ’{0 :+.6f} ;{1 :+.6f}’.format(x,−x)
’+327.768943 ; -327.768943’
8
CHAPITRE 1. MISE EN ROUTE
1.4
1.4. EXERCICES
Exercices
Ex 1 : Donner les valeurs des variables x, y et z à la fin de l’exécution du pseudo-code suivant :
x←4
y ←2+x
z ←x−y
y ←y+z
puis traduire ce pseudo-code en langage Python.
Ex 2 : Quelles sont les valeurs des variables a, b, q et r après la séquence d’affectations suivante ?
a = 19
b=6
q=0
r=a
r =r−b
q =q+1
r =r−b
q =q+1
r =r−b
q =q+1
Ex 3 : (a) Ecrire un programme qui affiche ’bonjour’ .
(b) Ecrire un programme qui demande un nom et affiche : ’bonjour’ + le nom tapé .
Ex 4 : (a) Affectez les variables temps et distance par les valeurs : 6.892 et 19.6. Calculer et afficher la
valeur de la vitesse.
(b) Améliorer l’affichage en imposant un chiffre après le point décimal .
Ex 5 : Saisir un nom et un âge en utilisant l’instruction input(). Les afficher.
Ex 6 : Ecrire un programme qui, à partir de la saisie d’un rayon et d’une hauteur, calcule le volume d’un cône
droit.
Ex 7 : Ecrire un programme qui, à partir de la saisie d’un taux de TVA et d’un prix TTC calcule le prix HT.
9
1.4. EXERCICES
CHAPITRE 1. MISE EN ROUTE
10