TP Python 3 - Le site de la SIN

Systèmes Numériques
S.I.N
PYTHON
Classe :
TSTI2D
Règles
de bases
1 Règles de bases du Python:
La syntaxe concerne les règles d'écriture à respecter . En langage
C ou Arduino vous avez dû apprendre la syntaxe de base suivante :
➢ Terminer une ligne par un point-virgule ;
➢ Terminer les instructions par un point-virgule ;
➢ Encadrer les sections de code (boucle, condition, fonction, .. ) par des accolades : une de
début { et une de fin }
{ // début section de code
instructions ;
} // fin section de code
En Python :
La structuration du code se fait à l'aide de l'indentation réalisée avec des tabulations (et pas des
espaces!!!) :
➢ Toutes les instructions qui se suivent ayant la même indentation sont considérées comme
faisant partie du même niveau
➢ Un retour d'indentation est considéré comme une « élévation » au niveau précédent
➢ Une nouvelle indentation crée un sous-niveau dans le niveau courant.
/10
1.1
Comparatif avec d'autres langages
/10
1.2 Premier pas avec l’interpréteur
➢ Lancez Pyscrypter
1.2.1
Les opérateurs :
➢ Nous allons maintenant dialoguer avec cet interpréteur Python : tapez les instructions de la
colonne de gauche et écrivez les résultats obtenus (les réponses de l'interpréteur), dans la
/10
colonne de droite, en commentant éventuellement (essayez de prévoir la réponse et, si elle
est différente, de comprendre pourquoi la réponse qui vous paraît logique n'a pas été celle de
l'ordinateur). Pour vous aider, vous avez le cours suivant ….courspython3.pdf page 21….
Instruction à taper
Résultat obtenu
et commentaire(s) ou explication(s)
20+1
20/3
20//3
20%3
5.45*10
2**4
(3+2)*5
3+2*5
20/0
20@3
"bonjour"/3
"bonjour" + 5
(3+2))*5 (3+2*5
Astuce : pour éviter d'avoir à retaper toute une ligne, utilisez la flèche “haut” du clavier pour vous
positionner sur cette ligne, puis tapez “Entrée” : la ligne est recopiée après l'invite de commande et vous
pouvez la modifier avant de taper à nouveau “Entrée”.
……………………………………………………….
……………………………………………………….
……………………………………………………….
……………………………………………………….
……………………………………………………….
1.2.2
Les types de données.
Booléens :
Les booléens comme dans tout langage peuvent prendre deux valeurs uniquement. En PYTHON, ces
valeurs sont True et False.
>>> mon_booleen = True
>>> mon_booleen
True
/10
Integer
L'entier/Integer est un nombre sans virgule. Il est codé sur quatre octets et sa
valeur peut s'étendre de -2 147 483 648 à +2 147 483 647.
>>> mon_integer = 56321
>>> mon_integer
56321
Long (Python2)
Ce type de valeur entière n'a comme limite que la capacité mémoire de l'ordinateur
>>> mon_long = 2147483648
>>> mon_long
2147483648L
Float
Le type float utilisé permet de manipuler des nombres (positifs ou négatifs) compris entre 10-308 et
10308 avec une précision de 12 chiffres significatifs. Ces nombres sont encodés d'une manière
particulière sur 8 octets (64 bits) dans la mémoire de la machine : une partie du code correspond
aux 12 chiffres significatifs, et une autre à l'ordre de grandeur (exposant de 10).
Attention : le caractère de séparation est le point et non la virgule.
>>> mon_float = 3.5632
>>> mon_float
3.5632
String (chaîne de caractères)
Une donnée de type string est une suite quelconque de caractères délimitée soit par des apostrophes
(simple quotes), soit par des guillemets (double quotes).
>>> phrase1 = 'le Luma ?'
>>> phrase2 = '"Yes", of course !!!'
>>> phrase3 = "Savez-vous cuire "
>>> print (phrase3, phrase1, phrase2)
Savez-vous cuire le Luma ? "Yes", of course !!!
Pour connaître le type d'une donnée, on utilise la méthode type()
Instruction à taper
Résultat obtenu
et commentaire(s) ou explication(s)
type(3)
type(1.5)
type("Jojo")
/10
type('Le luma')
type("3")
type(3+1.5)
type(12345678901234567890123456789
0123456789)
1.2.3
Les messages d'erreurs
L'étude des messages d'erreurs est fondamental.
Instruction à taper
Résultat obtenu
et commentaire(s) ou explication(s)
20/0
20@9
"bonjour"/7
"bonjour" + 5
(3+2))*98
(3+2*55
…………………………………………………
…………………………………………………
…………………………………………………
1.2.4
Le transtypage (cast)
On peut parfois avoir besoin de transformer une donnée d'un certain type, en une donnée d'un autre
type. Cela s'appelle le transtypage (ou cast en anglais).
Donnée de départ
De quel type est la
donnée de départ ?
Instruction(s) à taper
3.0
int(3.0)
3.5
int(3.5)
3
float(3)
4
str(4)
''3''
int(''3'')
''3.5''
float(''3.5'')
''3.5''
int(''3.5'')
''Jojo le luma ''
int(''Jojo le luma '')
Type du résultat obtenu
et/ou
commentaire(s)
/10
2 Les variables et l'affectation
2.1
Affectation
Il peut être pratique de ranger les données dans des contenants, aussi appelés variables, afin de les
conserver dans la mémoire de l'ordinateur pour les utiliser plus tard. Le rangement d'une donnée (un
contenu) dans une variable (un contenant) s'appelle l'affectation. L'affectation se fait grâce à l'opérateur
= qui s'appelle l'opérateur d'affectation.
L'affectation se fait en deux temps : (1) évaluation (c'est à dire calcul) de la partie à droite de
l'opérateur d'affectation (selon des règles de priorité de calcul correspondant au type des données
concernées). Le résultat de cette évaluation est la donnée (le contenu) qui va être rangée dans la
variable. (2) rangement du résultat de cette évaluation dans la partie à gauche de l'opérateur
d'affectation. Cette partie à gauche est la variable (le contenant).
Attention !!!
Affecter n’est pas comparer !
L’affectation a un effet (elle modifie l’état interne du programme en cours d’exécution) mais
n’a pas de valeur (on ne peut pas l’utiliser dans une expression) :
>>> a = 2
>>> x = (a = 3) + 2
SyntaxError: invalid syntax
La comparaison a une valeur utilisable dans une expression mais n’a pas d’effet :
>>> x = (a == 3) + 2
>>> x
2
Instruction à taper
Quelle est la variable ?
Quelle est la donnée (ou est le
résultat de l'évaluation de la
partie droite) ? De quel type est
cette donnée (ou ce résultat) ?
age=77
age=22
prenom='Jojo'
/10
taille_en_m= 1.22
taille_en_cm=taille_en_m*100
age=age + 3
phrase1= 'bonjour' + 'le' +
prenom
phrase1=phrase1 + '!'
phrase2=prenom + ' a' +
str(age) + ' ans.'
age
Remarque : le langage Python permet de faire plusieurs affectations à la fois, séparées par des
virgules sur une seule ligne. Exemple d'une telle affectation multiple :
>>> nom,prenom,age,etudiant="Student","Joe",20,True
2.1.1
Donner des noms aux variables
Un nom de variable doit :
➢ Débuter par une lettre minuscule.
➢ Contenir uniquement des lettres sans accents, des chiffres et le tiret de soulignement _ (appelé
tiret “underscore” ou encore “tiret du 8”).
➢ Être aussi explicite que possible (ne pas utiliser de noms trop courts et sans signification
comme a, b, x, y, n, mais utiliser plutôt age, longueur, nombre, somme...) Le langage Python fait
la distinction entre les majuscules et les minuscules. (casse)
➢ Il est possible (voir conseiller d'utiliser le « format chameau » par exemple : jojoLeLuma
Les mots clés réservés du langage ne peuvent pas être utilisés comme nom de variables (car ils sont
déjà “réservés” par le langage). Ce sont :
and as assert break class continue def del elif else except False
finally for from global if import in is lambda None nonlocal not or pass
raise return True try while with yield
Exercice :
Échangez la valeur de 2 variables ; écrire (sur papier) un algorithme pour échanger les valeurs de 2
variables que vous nommerez var1 et var2.
Testez avec votre interpréteur python.
…………………………………………………..
…………………………………………………..
…………………………………………………..
2.1.2
Typage des variables sous Python
Sous Python, il n'est pas nécessaire d'écrire des lignes de programme spécifiques pour définir le
type des variables, avant de pouvoir les utiliser ; il suffit d'assigner une valeur à un nom de
variable pour que celle-ci soit automatiquement créée avec le type qui correspond au mieux à la
/10
valeur fournie. Ceci constitue une particularité intéressante de Python, qui le rattache à une famille
particulière de langages.
On dira à ce sujet que le typage des variables sous Python est un typage dynamique, par opposition
au typage statique qui est de règle par exemple en C++ ou en Java.
Dans ces langages, il faut toujours, par des instructions distinctes, d'abord déclarer (définir) le nom
et le type des variables, et ensuite seulement leur assigner un contenu, lequel doit bien entendu être
compatible avec le type déclaré. Le typage statique est préférable dans le cas des langages compilés,
parce qu'il permet d'optimiser l'opération de compilation (dont le résultat est un code binaire « figé
»).Le typage dynamique quant à lui permet d'écrire plus aisément des constructions logiques de
niveau élevé (métaprogrammation, réflexivité), en particulier dans le contexte de la programmation
orientée objet (polymorphisme). Il facilite également l'utilisation de structures de données très
riches telles que les listes et les dictionnaires.
3 Les variables et les opérateurs logiques
Le type booléen ou bool est un type de données. Un booléen ne peut prendre que 2 valeurs : vrai
(True) ou faux (False).
NB : Les majuscules sont importantes : true et false ne sont pas reconnues par le programme, il faut
écrire True et False. Les opérateurs qui s'appliquent aux booléens s'appellent opérateurs logiques.
Ce sont : not (NON), and (ET), or (OU). D'autres opérateurs s'appliquent à des données numériques
ou chaînes de caractères et produisent un résultat booléen : ce sont les opérateurs de comparaison :
= = signifie “est égal à” != signifie “est différent de” < , <= , > , >= signifient “est inférieur,
inférieur ou égal, supérieur, supérieur ou égal” . Ces opérateurs permettent de faire des tests. Le
résultat de l'opération est True si le test est vrai, False si le test est faux.
Instruction à taper
Résultat obtenu
et commentaire(s) ou explication(s)
1 == 1
1 == 3
1 != 3
1 == 1.0
(3+7) == (5*2)
(1 == 1) and (2<2)
(1 == 1) and (2<=2)
(2 == 15) or (3>2)
1 < 4 < 15
valeur = (1==1)
type(valeur)
not(valeur)
True and False
/10
True or False
Les tables de vérité de “ not ”, “ and ”, “ or ” Les opérateurs logiques not, and, or, opèrent de
la façon suivante : soient A et B des propositions.
“ non A ” est vrai ⇔A est faux
“ non A ” est faux ⇔A est vrai
“ A et B ” est vrai ⇔(A est vraie) et (B est vraie)
“ A et B ” est faux ⇔(A est fausse) ou (B est fausse)
“ A ou B ” est vrai ⇔(A est vraie) ou (B est vraie)
“ A ou B ” est faux ⇔(A est faux) et (B est faux)
4. Points clés à retenir et questionnement.
➢ Quels sont les types de données de Python?
➢ Qu'est-ce que le transtypage ?
➢ Quelles sont les opérateurs arithmétiques et logiques de Python?
Notre activité s'arrête ici ….
/10