BCPST 1B Informatique. Programmation en Python. Ce document

BCPST 1B13 septembre 2015
Informatique. Programmation en Python.
Ce document est un support de cours, il vous permet d’avoir sa structure et ses ´el´ements les plus importants. Au
cours des s´eances en classe vous devez compl´eter ce cours par toutes les remarques, exemples, d´emonstrations
qui seront faites oralement et au tableau.
Vous devez pour cela prendre des notes sur une autre feuille. Vous devez aussi reprendre sur cette
feuille annexe toute la structure du cours.
−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
Par d´efaut, ce qui est pr´esent´e concerne Python 3.x. Nous verrons par moment les diff´erences avec l’autre
version : Python 2.x. Il est important de savoir qu’il y a deux versions.
1) Interfaces.
L’ex´ecution d’un programme Python peut se faire `a l’aide de plusieurs interfaces, nous utiliserons Pyzo
qui est celle utilis´ee au concours.
Nous utiliserons aussi une interface web tr`es pratique : http ://www.pythontutor.com/
Cette interface permet d’ex´ecuter pas `a pas de petits programmes Python. Elle permet aussi de voir
l’´evolution des variables au cours de l’ex´ecution. L’utilisation de cette interface est limit´ee aux petits
programmes n’utilisant pas trop de biblioth`eques.
Exemple de programme.
n=1
while n<10:
n=n+2
print(n)
V´erifier, `a travers cet exemple, que vous savez :
Lancer les deux interfaces.
Copier le programme dans chaque interface.
Obtenir le r´esultat du programme dans chaque interface.
2) Les variables.
Les variables en python sont des noms associ´es `a des espaces m´emoires. On peut y stocker une valeur,
acc´eder `a son contenu et parfois changer son contenu.
A chaque affectation d’une valeur `a une variable on change l’adresse m´emoire sur laquelle pointe la variable.
Nous verrons plus tard que pour certains types de variables (mutables comme les listes), on peut modifier
la valeur d’une variable sans changer l’adresse m´emoire.
Les valeurs prises par ces variables peuvent ˆetre de diff´erents types.
Pour connaˆıtre le type d’une valeur ou d’une variable il suffit d’utiliser la fonction type().
1

a) Les types simples.
Les entiers.
Op´erations sur les entiers. +, −, * , // , % et **
Les r`egles de calculs sont les mˆemes qu’en math´ematiques, on utilise des parenth`eses pour indiquer
l’ordre des op´erations.
Il n’y a pas de limitation de taille pour les entiers.
Les flottants.
Ce sont des nombres ”`a virgule”. On utilise le symbole ”.” `a la place de la virgule.
Op´erations sur les flottants : +, −, * , / , **
Python affichera les flottants avec au maximum 17 chiffres significatifs et si n´ecessaire en notation
scientifique.
Dans un calcul m´elangeant des entiers et des flottants il risque d’y avoir des probl`emes. Python
transforme un entier en flottant si n´ecessaire.
Remarque : Python 3.x transforme tout en flottant d`es qu’il y a un ”/”.
Attention : La repr´esentation des nombres d´ecimaux par des flottants n’est pas exacte.
Pour aller plus loin :
Pour stocker le nombre 0.4 : on approche au mieux ce nombre en binaire :
0,011001100110011001100110011001100110011001100110011010
qui est ´egale `a : 7205759403792794
18014398509481984
ce nombre vaut environ :
0,400000000000000022204460492503
Les bool´eens.
Il est souvent n´ecessaire de faire des tests, des branchements (Si ... Faire)
Les bool´eens peuvent prendre deux valeurs : ”True” et ”False”
Nous les utiliserons dans les branchements et les boucles conditionnelles (if et while).
Construction de bool´een. == ,<,<= ,>,>= ,!= et in
Les op´erations sur les bool´eens sont :
not : la n´egation (le ”Non” logique)
and : la conjonction (le ”et” logique)
or : le disjonction (le ”ou” logique)
On peut r´esumer dans ce tableau l’action de ces op´erations sur les diff´erentes valeurs :
ABnot A A and B A or B
True True
True False
False True
False False
Attention `a la comparaison des flottants (Par exemple : 3 ∗0.1 == 0.3 )
V´erifier que vous savez :
Faire des op´erations avec des entiers, des flottants.
Que font % et // sur les entiers ?
Utiliser les op´erations and et or.
D´eterminer le type d’une variable.
(Par exemple : en d´efinissant A=4/2, v´erifier que A est bien un flottant. )
2

b) Les chaˆınes de caract`eres : strings.
Ce type permet de repr´esenter des textes. Une chaˆıne caract`ere est une suite finie de caract`eres qu’on
note entre apostrophes ’...’ ou entre guillemets ”...”.
Acc`es `a un caract`ere : Pour acc´eder aux caract`eres d’une chaˆıne Aon utilise l’expression A[i] o`u i
est la position (l’indice) du caract`ere.
Attention : En python, l’indice du premier caract`ere est 0 et non 1.
Sous-chaine : Pour extraire une partie d’une chaˆıne on utilise l’expression A[i:j] o`u iest l’indice du
premier caract`ere et jl’indice du dernier caract`ere plus un. (On va de icompris `a jexclu)
Concat´enation : Avec les op´erateurs + et ∗.
Longueur : On utilise la fonction len
Pour aller plus loin :
Nous verrons plus tard des m´ethodes plus ´evolu´ees qui s’appliquent `a ce type d’objet :
join,count,split ...
Un exemple avec split et join :
Base=’Le-petit-chat-est-mort’
Mots=Base.split(’-’)
Texte=’ ’.join(Mots)
print(Texte)
Conversion entre chaˆınes de caract`eres et types simples. (Transtypage)
Exemple :
A=’21’
B=int(A)
C=2*A
D=2*B
Que contient les diff´erentes variables ? Quel est leur type ?
Nous pouvons pas modifier une chaˆıne de caract`ere. Pour pouvoir modifier les caract`eres d’une chaine
on passe par une liste, type que nous verrons dans la suite du cours.
V´erifier que vous savez :
cr´eer une variable du type chaˆıne de caract`ere.
extraire une partie d’un texte.
concatener deux textes.
c) Affectation, initialisation, ´etat et typage dynamique.
Au d´ebut d’un programme, il n’y a ”rien” en m´emoire. On initialise des variables, on fait ´evoluer ce
qu’elles contiennent `a l’aide d’instructions. La premi`eres de ces instructions est l’affectation.
La premi`ere affectation est appel´ee initialisation.
A chaque affectation, Python red´efinit le type de la variable (typage dynamique).
Ci-dessous nous donnons une suite d’instructions en Python,
D´eterminer `a chaque ligne du tableau l’´etat de la m´emoire apr`es l’affectation indiqu´ee, (on pourra
aussi indiquer les initialisations).
ABC
A=2
A=A+2
B=A*2+2
C=4
C=B-C
C=C+A-B;
A=B-C*A
A=(B-A)*C
B=(A+C)*C
3

d) Les listes.
C’est le type de variable le plus utilis´e en Python.
C’est la traduction informatique du produit cart´esien d’ensembles.
Pour construire une liste, on ´ecrit des valeurs (de tout type) entre crochets s´epar´ees par des virgules.
Attention : En python, l’indice de la premi`ere composante est 0 et non 1.
Acc`es aux composantes : Pour acc´eder aux composantes de ce n-uplet on utilise l’expression A[i] o`u
iest le num´ero (l’indice) de la composante.
On retrouve ainsi les mˆemes fonctions et op´erateurs que pour les chaines de caract`eres : + , ∗len(),
in.
On peut aussi num´eroter `a partir de la fin : la derni`ere composante A[-1], l’avant derni`ere A[-2],
l’ant´ep´enulti`eme A[-3] ...
Pour aller plus loin :
Nous verrons aussi de nombreuses m´ethodes qui agissent sur l’objet list.
sort ,append ,insert ...
V´erifier que vous savez :
cr´eer une variable de type liste ou tuple.
acc´eder `a une des valeurs d’une liste.
acc´eder `a une plage de valeurs d’une liste (une sous-liste).
ajouter une valeur `a la fin ou au d´ebut d’une liste.
ajouter une valeur `a une place quelconque d’une liste (par exemple `a la deuxi`eme place).
e) D’autres types.
Les tuples, les ensembles, les dictionnaires, les fichiers, les fonctions ...
Nous les reverrons plus tard.
3) Entr´ees/sorties.
Pour afficher le contenu d’une variable `a l’´ecran. print
Pour entrer une valeur au clavier. input
Exemple : a=input(’Entrer une valeur’)
Ce qui est entr´e par l’utilisateur est de type string (chaine de caract`eres).
Pour entrer d’autres types de variables, il faut utiliser les fonctions de transtypage.
Exemple : a=float(input(’Entrer une valeur’)) ou Exemple : a=int(input(’Entrer une valeur’))
V´erifier que vous savez :
afficher la valeur d’une variable.
entrer une valeur avec input.
entrer avec input deux valeurs enti`eres et afficher avec print la somme des deux nombres.
Exercices :
➀Ecrire un programme qui demande les coefficients d’un trinˆome et qui affiche son discriminant.
➁Ecrire un programme qui demande un mot de 5 lettres et qui affiche le mot `a l’envers.
➂Ecrire un programme qui demande un entier `a trois chiffres et qui affiche la somme de ses chiffres.
➃Ecrire un programme qui demande un entier `a quatre chiffres et qui affiche le plus grand de ses chiffres.
➄Ecrire un programme qui demande un entier et qui affiche le nombre de chiffre de cet entier.
➅Donner la liste des nombres de trois chiffres ´egaux `a la somme des cubes de leurs chiffres.
4

4) Instructions conditionnelles.
•Test simple. if
En Python la syntaxe est :
if condition :
bloc d instructions
Le bloc d’instructions est ex´ecut´e uniquement si la condition est v´erifi´ee.
Attention aux deux points et `a l’indentation.
En Python, c’est la fin de l’indentation qui indique la fin du bloc il n’y pas de ”FinSi”.
•Test avec alternative. if else
En Python la syntaxe est :
if condition :
bloc d instructions si la condition est v´erifi´ee
else :
bloc d instructions si la condition n est pas v´erifi´ee
•Avec plusieurs alternatives : if elif else
if condition 1 :
bloc d instructions si la condition1 est v´erifi´ee
elif condition 2 :
bloc d instructions si la condition1 n est pas v´erifi´ee et la condition2 est v´erifi´ee
else :
bloc d instructions si aucune condition n est v´erifi´ee
Un exemple :
a=float(input(’Entrer une valeur pour a : ’))
b=float(input(’Entrer une valeur pour b : ’))
c=float(input(’Entrer une valeur pour c : ’))
if b*b-4*a*c>0 :
print(’Le discriminant strictement positif’)
print(’le polynome a deux racines r´eelles distinctes’)
elif b*b-4*a*c==0 :
print(’Le discriminant est nul’)
print(’le polynome a une racine double’)
else :
print(’Le discriminant strictement n´egatif’)
print(’le polynome n’a pas de racines r´eelles’)
V´erifier que vous savez :
faire un petit programme avec un if
faire un petit programme avec un if else
faire un petit programme avec un if elif else
5) Boucle Pour
Une boucle est une construction permettant de r´ep´eter un bloc d’instructions.
En Python la syntaxe pour une boucle for classique est :
for k in range(n):
bloc d instructions
Attention aux deux points et `a l’indentation.
En Python, c’est la fin de l’indentation qui indique la fin du bloc il n’y pas de ”FinPour”.
La variable kest appel´ee ”compteur de boucle”.
C’est un entier qui prend successivement les valeurs 0, 1, 2 ... et (n−1).
Le bloc d’instructions est ex´ecut´e pour chaque valeur de k.
Le bloc d’instructions peut d´ependre, ou non, de la valeur de k.
5