Inititiation À Python

Python - Une initiation en 13 étapes
Sommaire
1. Bonjour monde
2. Notion de variables
3. Un peu de calculs
4. Chaînes de caractères
5. Les fonctions
6. Expressions et booléens
7. Les conditions
8. La boucle "tant que..."
1/36
9. Les séquences : tuples et tableaux
 La boucle "for" pour parcourir un tableau
10. Lire dans un fichier
11. Commenter son code
12. Un petit projet
13. Tracer des graphiques avec matplotlib
14. Pour aller plus loin sur magistère
Source :
Le contenu ci-dessous est honteusement pompé et parfois librement adapté du travail de David Roche,
disponible notamment sur : https://pixees.fr/informatiquelycee/n_site/nsi_prem_pythonbase.html
Programmer un ordinateur, c'est quoi ?
Programmer, c'est créer des programmes (suite d'instructions données à l'ordinateur) ! Un ordinateur sans
programme ne sait rien faire. Il existe différents langages qui permettent de programmer un ordinateur,
mais le seul directement utilisable par le processeur est le langage machine (suite de 1 et de 0).
Aujourd'hui (presque) plus personne ne programme en langage machine (trop compliqué).
Les informaticiens utilisent des instructions (mots souvent en anglais) en lieu et place de la suite de 0 et de
1. Ces instructions, une fois écrites par le programmeur, sont « traduites » en langage machine. Un
programme spécialisé assure cette traduction. Ce système de traduction s'appellera interpréteur ou bien
compilateur, suivant la méthode utilisée pour effectuer la traduction.
Il existe 2 grandes familles de langages de programmation :
 Les langages de bas niveau sont très complexes à utiliser, car très éloignés du langage naturel, on
dit que ce sont des langages « proches de la machine », en contrepartie ils permettent de faire des
programmes très rapides à l'exécution. L'assembleur est le langage de bas niveau. Certains
"morceaux" de programmes sont écrits en assembleur encore aujourd'hui.
 Les langages de haut niveau sont eux plus "faciles" à utiliser, car plus proches du langage naturel
(exemple : si a=3 alors b=c). Exemples de langages de haut niveau : C, C++ , Java, Python...
Pour écrire nos programmes, nous utiliserons le logiciel EduPython (mais il existe beaucoup d'autres
logiciels permettant de faire la même chose : Spyder, jupyter, IDLE, Pycharm...).
Lycée Saint Marc, Nivolas Vermelle Initiation à Python Tsi 2019-2020

1- "Bonjour monde !"
Le premier exercice de tout (bon) tuto de programmation consiste à écrire un programme qui déclame
fièrement "Bonjour le monde !" au monde.
Lancez EDUPYTHON Barres de menus et d’outils
Pour vous repérez ...
Zone de saisie du code

Explorateur
de fichiers
2/36
Console EDUPYTHON
En python, la commande qui permet d'afficher dans la console EDUPYTHON (CEP) un texte est la
commande print():
print("quelque chose")
Dans la console saisissez la commande : print("Bonjour the world")
2- Notion de variable
Définition du mot ordinateur d'après "Le Petit Larousse" :
"Machine automatique de traitement de l'information, obéissant à des programmes formés par des suites
d'opérations arithmétiques et logiques."
Qui dit "traitement de l'information" dit donc données à manipuler. Un programme "passe" donc son
temps à traiter des données. Pour pouvoir traiter ces données, l'ordinateur doit les ranger dans sa
mémoire (RAM - Random Access Memory). La RAM se compose de cases dans lesquelles nous allons
ranger ces données (une donnée dans une case). Chaque case a une adresse (ce qui permet au processeur
de savoir où sont rangées les données).
Alors, qu'est-ce qu'une variable ?
Eh bien, c'est une petite information (une donnée) temporaire que l'on stocke dans une case de la RAM.
On dit qu'elle est "variable", car c'est une valeur qui peut changer pendant le déroulement du programme.

Ma première variable
Une variable est donc constituée de 2 choses :
 Elle a une valeur : c'est la donnée qu'elle "stocke" (par exemple le nombre entier 42)
 Elle a un nom : c'est ce qui permet de la reconnaître. Nous n'aurons pas à retenir l'adresse de
mémoire, nous allons juste indiquer des noms de variables à la place.
Ainsi l'instruction :
reponse = 42
Définit une variable appelée reponse et qui contient la valeur 42. Plus précisément, nous dirons que la
3/36
variable reponse référence le nombre entier 42.
NB : Mais si la réponse est '42', quelle était la question ???...
Pour connaître la valeur référencée par une variable, il suffit de taper le nom de la variable et d'exécuter la
commande
Ecrire et tester sur la CEP une instruction qui affecte la valeur 15 à une variable dont le nom est
points_de_vie et afficher maintenant la valeur de votre variable points_de_vie:
Entrée 2 :
On récapitule : créer une variable et afficher sa valeur dans son premier programme¶
Écrire un programme dans lequel on attribue la valeur 12 à la variable points_de_force. La valeur

référencée par la variable points_de_force devra ensuite être affichée dans la console.
NB : un "programme" est une suite d'instructions. En python, les instructions consécutives sont séparées par
un simple retour à la ligne.
Votre premier programme Cliquer sur la flèche verte pour exécuter le programme
Affichage du résultat dans la CEP

Les types
Nous n'avons pour l'instant travaillé qu'avec des nombres entiers, essayez pour voir d'attribuer maintenant
la valeur 3.1415 à une variable appelée environPi
Entrée 3 : environPi=3.1415
On appelle "type" la nature de la valeur référencée dans une variable. Pour connaitre le type d'une variable
(plus rigoureusement de la valeur qu'elle référence), on peut utiliser l'instruction :
type(ma_variable)
Utiliser cette instruction pour connaître les types des variables points_de_vie et environPi et vérifier dans
la CEP la cohérence des résultats obtenus. 4/36
Entrée 4 : type(points_de_vie)
Entrée 5 : type(environPi)
Une variable peut donc référencer plusieurs types d'entités (pour l'instant nous n'en avons vu que deux,
mais nous en verrons d'autres plus loin) : les nombres entiers ("integer" en anglais, abrégé en "int") et les
nombres à virgule ("float" en anglais).
3. Un peu de calculs
Un ordinateur est bien évidemment capable d'effectuer des opérations mathématiques (arithmétiques).
Les signes utilisés sont classiques : +, - , * , / , // (division euclidienne) ou encore % (modulo : reste d'une
division euclidienne).
L'écriture a**b signifie "a à la puissance b"
Il est tout à fait possible d'effectuer des opérations directement avec des nombres, mais il est aussi
possible d'utiliser des variables.
Faire un calcul
Essayez d'écrire un programme qui additionnera le contenu de 2 variables appelées a et b. Le résultat de

cette opération devra être référencé par une troisième variable nommée resultat (attention pas d'accent
dans les noms de variable).
Testez votre programme en affichant finalement la valeur référencée par la variable resultat.
Entrée 6 :

Affectation : le signe " = "
Comme dans l'instruction a = 12 qui affecte à a la valeur 12 , il faut comprendre que lors d'un calcul, le
signe = est une affectation (et non une égalité) de la valeur évaluée à sa droite vers la variable présente à
sa gauche, ainsi, ce qui peut surprendre au premier abord, la syntaxe du programme :
a = 12
a = a + 42
print(a)
est tout à fait correct.
D'ailleurs quel est son résultat ? tester le code 5/36
Entrée 7 : 54
On a affecté à a le résultat de l'addition a+42
Exposant, racine carrée, fonctions trigonométriques : appel à un module
Il est aussi possible d'effectuer des calculs plus complexes en utilisant par exemple des exposants, des
racines carrées, des fonctions trigonométriques...
Pour utiliser ces fonctions mathématiques plus avancées, il est nécessaire d'ajouter une ligne au début de
votre programme :
import math
Cette ligne permet d'importer (et donc d'utiliser) le module "math" (ce module contient toutes les
fonctions mathématiques "classiques").
Voici quelques exemples :
 math.pow(x,a) permet de calculer x à la puissance a

 math.cos(x) permet de calculer le cosinus de l'angle x (l'angle x doit être en radian) (nous avons la
même chose pour le sinus ou la tangente)
 math.sqrt(x) permet de calculer la racine carrée de x
Si vous avez besoin d'autres fonctions mathématiques, vous pouvez consulter la documentation de
Python : https://docs.python.org/3/library/math.html
Saurez-vous faire un programme qui puisse afficher :

 la factorielle de 7 ?
 l'exponentielle de 23 ?
 la racine cubique de 97 ?
Entrée 5040
8 :
9744803446.24889
3.138288992714996
6/36

4. Chaînes de caractères
Il est tout à fait possible de référencer dans une variable une "chaîne de caractères"
Prouvez-le en tapant un programme qui affecte "Bonjour, monde !" à une variable appelée message, que
vous afficherez ensuite.
Entré
e 9 :
7/36
Concaténons !
Wikipédia nous dit que :

La concaténation, du latin cum («avec») et catena(«chaîne, liaison»), désigne l'action de mettre bout à
bout au moins deux chaînes.
L'opérateur utilisé pour concaténer deux chaines est le signe "+".
Il est possible de concaténer aussi bien directement des chaînes de caractères que des variables contenant
des chaines de caractères.
Complétez le programme commencé ici pour qu'il affiche "Bonjour, Kevin et Johnny!"

Entrée10
8/36
Chaînes de caractères et variables
Python ne permet pas de concaténer des chaines de caractères avec d'autres types, le programme :
police = 12.4
syndicats = 345733
decompte = "Il y avait entre " + police + " et " + syndicats +" manifestants dans la rue cet après-midi"
print(decompte)
va renvoyer un message d'erreur : on ne doit concaténer que des chaines de caractères entre elles.
Essayez donc de mettre à profit l'instruction str() pour venir à notre aide et informer la population.
Entré
e 11 :
Outre l'utilisation de str(), il est également possible d'utiliser (depuis python 3.5) les fstring avec la syntaxe
suivante :
pivot = 58
generation = 57
newsflash = f"L'age de la retraite finalement porté à {pivot} ans pour la génération
{generation}"newsflash

9/36

Notez :
 la présence du f avant la chaine de caractères

 les variables qui ne sont pas de type chaine de caractères sont entre accolades { }
 le retour à la raison du gouvernement
Essayez donc d'afficher le décompte des manifestants avec cette méthode :
Entré Tester votre code sur https://repl.it/languages/python3

e 12 :
10/36
5. Les fonctions
Les fonctions permettent de décomposer un programme complexe en une série de sous-programmes plus
simples. De plus, les fonctions sont réutilisables : si nous disposons d'une fonction capable de calculer une
racine carrée, par exemple, nous pouvons l'utiliser un peu partout dans notre programme sans avoir à la
réécrire à chaque fois (on parle de factorisation du code)
La notion de fonction en informatique est comparable à la notion de fonction en mathématiques.
Si nous avons y = 3.x + 2, pour une valeur donnée de x, nous aurons une valeur de y.
Exemple : pour x = 4 , y = 14 (y = 3*4 + 2 = 14).
La fonction en informatique est basée sur la même idée :

La syntaxe employée en python pour définir une fonction est la suivante :
def nom_de_la_fonction(parametre):
instruction_1
instruction_2
return y
suite du programme...
La fonction renvoie la valeur contenue dans la variable y.
ATTENTION : Notez bien la présence du décalage entre la première ligne et les lignes suivantes. Ce
décalage est appelé indentation, l'indentation permet de définir un bloc de code.
Dans l'exemple ci-dessus : 11/36
l'indentation nous permet de savoir que "instruction_1", "instruction_2" et "return y" constituent un bloc
de code, ce bloc correspond au contenu de la fonction
"suite du programme" ne fait pas partie de la fonction, car il n'est pas indenté.
Pour indenter du code, il y a 2 solutions : mettre 4 espaces ou utiliser une tabulation. En Python il est
conseillé d'utiliser les 4 espaces, mais ce n'est pas une obligation (personnellement, j'utilise plutôt les
tabulations...). Une chose est sûre, une fois que vous avez choisi une méthode, n'en changez surtout pas au
cours d'un même programme !
Pour "utiliser" la fonction ma_fonction , il suffit de l'appeler avec une valeur donnée de son paramètre en
écrivant par exemple :
ma_fonction(4)
Essayez donc ci-dessous de coder une fonction :
qui s'appelle : ma_fonction ,
qui prenne un paramètre appelé x,
qui renvoie la valeur y : y = 3.x + 2
Affectez alors le résultat à une variable appelée resultat et affichez cette valeur :
Entrée 13 14

Il est possible de passer plusieurs paramètres à une fonction, en les séparant par une virgule ",".
Modifiez la fonction précédente pour en faire une fonction à plusieurs variables : x , a et b , dont le résultat
sera la valeur donnée par : a * x + b :
Entrée 14
14
12/36
Ici encore, les variables peuvent avoir différents types : écrire une fonction :
 s'appelant mon_dessert
 qui prenne 2 paramètres :
 "fruit" (de type "chaine de caractères")
 "nombre" (de type "entier")
 qui renvoie comme résultat la phrase : "Pour dessert, j'ai mangé (nombre) (fruit)"
Appeler finalement cette fonction de sorte qu'elle affiche : "Pour dessert, j'ai mangé 3 bananes"

e 15
Il faut aussi savoir qu'une fonction ne renvoie pas forcément de valeur (le mot clé return n'est pas
obligatoire).
Mais si elle ne renvoie pas de valeur, que fait-elle ? Elle peut faire plein de choses, par exemple elle peut
tout simplement afficher une chaîne de caractères à l'aide d'un "print". Sachez que dans certains langages,
on utilise les termes méthode ou procédure pour qualifier une fonction "qui ne renvoie rien".
Modifiez votre fonction mon_dessert() pour qu'elle ne renvoie aucun résultat mais imprime elle-même la
phrase "Pour dessert..."
e 15b
13/36
6. Les expressions et les booléens
Si quelqu'un vous dit que "4 est égal à 5", vous lui répondez quoi ? "C’est faux". Si maintenant la même
personne vous dit que "7 est égal à 7", vous lui répondrez bien évidemment que "c'est vrai".
En Python, ces deux «affirmations» ("4 est égal à 5" et "7 est égal à 7") s'appellent des expressions, elles
s'écriront :
4 == 5
7 == 7
Notez bien le double signe égal !!
ATTENTION : notez le double égal "==" qui permet de distinguer une expression et une affectation
(référencement d'une valeur par une variable). Le fait de confondre le "simple égal" et le "double égal"
est une erreur classique qu'il faut éviter.
Le signe "==" est appelé opérateur d'égalité, alors que signe "=" est l'opérateur d'affectation.
Une expression peut soit être vraie (True), soit fausse (False)
Ecrire ci-dessous une expression vraie et une expression fausse et afficher leur valeur ( True et False ) :
Entrée 16 : CEP : 20==20  True
1==2  False
Pour l'instant nous avons vu deux grands types de données : les nombres (entier ou flottant) et les chaînes
de caractères, il existe un troisième type tout aussi important que les deux premiers : les booléens.
Un booléen est un type de données qui ne peut prendre que deux valeurs : vrai ("True") ou faux ("False"). Il
est donc possible d'affecter à une variable de type booleen la valeur d'une expression, cette variable aura
alors pour valeur 'True' ou 'False', comme dans cet exemple :

Entrée 17 : a=6
b=4
egalite = a==b
print(egalite)
Déduire du programme suivant, la signification de l'opérateur "!=" saisir et tester...
Entrée 18 : a=6

b=4
egalite = a !=b
print(egalite)
14/36
 « != » signifie « non égal à »

L'opérateur !=" est l'opérateur "différent de"
Exemples d'opérateurs de comparaison :
 == : "égal à"

 != : "différent de"
 < : "strictement inférieur à"
 > : "strictement supérieur à"
 <= : "inférieur ou égal à"
 >= : "supérieur ou égal à"
7. Les conditions
Pouvoir comparer des valeurs, c'est bien, mais pouvoir adapter son programme au résultat obtenu, en
fonction de valeurs d'expressions évaluées, ce serait mieux : comme disait l'autre "Décider, c'est choisir"
(ou le contraire ?).
Pour pouvoir écrire un programme capable de réagir différemment selon qu'un nombre est supérieur ou
inférieur ou égal à un autre, il faudrait pouvoir coder cette notion de si .... alors .... ou bien... sinon...
Une structure fondamentale en programmation (en algorithmique) est donc le : si... alors... sinon
Sa syntaxe en python est la suivante :
faire des choses

if expression :
faire un truc
faire un machin
...
else :
faire un autre truc
faire un autre machin
...
continuer à faire des choses
Ici, si "expression" est True (vrai) alors le programme va faire un truc et faire un machin sinon (c'est à dire si
expression est False (faut)) alors le programme va faire un autre truc et faire un autre machin
On notera :
 l'indentation du bloc d'instructions concernées par le if et du bloc de celles concernées par le else:
c'est cette indentation seule qui définit quelles sont les instructions à effectuer ou pas, selon que
la condition testée par le if est vraie ou non
 que les conditions if et else sont au même niveau d'indentation
 la présence des deux points ":" en fin des lignes if et else
Saurez-vous compléter et tester le programme ci-dessous qui doit dire si a est plus grand que b ?
15/36
Entrée a = 40
19 : b = 37
___ a>b:
print('a
est plus
grand que
b')
____:
print('a
est plus
petit que b')
Écrire une fonction nommée saloon qui prend en paramètre un âge.

Cette fonction devra renvoyer la chaîne de caractères : "Bienvenue étranger, prends donc une bière !" ou
"Holà, muchacho ! Tu m'as l'air bien tendre pour entrer dans mon saloon !" selon que l'âge est supérieur à
18 ans ou non.
Entré
e 20 :

16/36
Vous êtes gérant d'un magasin et vous désirez écrire un programme Python qui calculera
automatiquement le montant de la facture des clients.
Tout client qui achète au moins 5 fois le même article se voit octroyer une remise de 5 %. Afin de simplifier
le problème, on considère qu'un client n'achète qu'un seul type d'article.
Écrire une fonction qui prend en paramètre le prix unitaire de l'article et le nombre d'articles achetés et
qui doit renvoyer le montant de la facture.
Tester votre code sur https://repl.it/languages/python3
Entré
e 21 :
Opérateurs logiques "et", "ou"
On peut combiner plusieurs expressions à l'aide d'opérateurs logiques.
Nous allons étudier 2 opérateurs logiques : le "ou", noté en Python or et le "et", noté en Python and.
L'expression expression1 and expression2 est vrai si les deux expressions 1 et 2 sont vraies simultanément.
L'expression expression1 or expression2 est vrai si l'une au moins des deux expressions 1 et 2 est vraie.
Ces résultats peuvent être regroupés dans ce que l'on appelle une table de vérité :

Ecrire une fonction prenant un paramètre de type entier et ne contenant qu'un seul test if, qui renvoie
"note valide" ou "note non valide" selon que le paramètre qui lui est envoyé est compris entre 0 et 20 ou
non.
17/36
Entrée
22 :
8. La boucle "tant que..." (while)
La notion de boucle est fondamentale en informatique. Une boucle permet d'exécuter plusieurs fois des
instructions qui ne sont présentes qu'une seule fois dans le code.
La structure de la boucle while est la suivante :
while expression :
instruction1
instruction2
suite programme
Tant que l'expression s'évalue à "True", les instructions à l'intérieur du bloc (partie indentée) seront
exécutées.
A partir d'une variable « i »valant 0, écrire un programme qui "compte" jusqu'à 17.
(rappel : on incrémente une variable (on augmente sa valeur de "1"),

en lui ajoutant simplement "1" : i = i + 1 )
Entrée 23 :

Créez un générateur de punition : votre fonction prendra deux arguments :
 une chaine de caractères (le texte de la punition)

 un entier (le nombre de lignes à faire) Vote fonction devra sortir le texte complet d'une punition du
type "recopiez 50 fois "je ne dois pas sous-traiter ma punition à un ordinateur" "
Tester votre code sur https://repl.it/languages/python3
Entrée 24 :
18/36
Écrire une fonction permettant d'afficher une table de multiplication. Cette fonction devra prendre en
paramètre la table désirée.
Par exemple si l'on passe le paramètre 3 à la fonction, la fonction devra permettre d'afficher :
1x3=3
2x3=6
...
...
10 x 3 = 30
Entré
e 25 :
9. Les séquences en python
Pour travailler avec des séries de valeurs, il est possible de "stocker" plusieurs grandeurs dans une même
structure, ce type de structure est appelé une séquence.
De façon plus précise, nous définirons une séquence comme un ensemble fini et ordonné d'éléments
indicés de 0 à n-1 (si cette séquence comporte n éléments). Rassurez-vous, nous reviendrons ci-dessous
sur cette définition.

Nous allons étudier plus particulièrement 2 types de séquences : les tuples et les tableaux (il en existe
d'autres que nous n'évoquerons pas ici).
Les tuples
Comme déjà dit ci-dessus, un tuple est une séquence. Voici un exemple très simple :
mon_tuple = (5, 8, 6, 9)
Dans le code ci-dessus, la variable "mon_tuple" référence un tuple, ce tuple est constitué des entiers 5, 8, 6
et 9. Comme indiqué dans la définition, chaque élément du tuple est indicé (il possède un indice):
 le premier élément du tuple (l'entier 5) possède l'indice 0 19/36

 le deuxième élément du tuple (l'entier 8) possède l'indice 1
 le troisième élément du tuple (l'entier 6) possède l'indice 2
 le quatrième élément du tuple (l'entier 9) possède l'indice 3
Comment accéder à l'élément d'indice i dans un tuple ?
Simplement en utilisant la "notation entre crochets" :
mon_tuple[i]
ATTENTION : dans les séquences les indices commencent toujours à 0 (le premier élément de la séquence
a pour indice 0), oublier cette particularité est une source d'erreur "classique".
Il n'est pas possible de modifier un tuple après sa création (on parle d'objet "immutable").
Si vous avez compris, vous devez savoir quelle est la valeur de la variable a dans l'exemple ci dessous :
mon_tuple = (5, 8, 6, 9) Tester le code dans un programme.
Entrée 26 : a = mon_tuple[2]
print(a) Réponse :
Un tuple ne contient pas forcément des nombres entiers, il peut aussi contenir des nombres décimaux, des
chaînes de caractères, des booléens...
Complétez le programme ci dessous pour que le programme affiche "Bonjour le monde !" :
mots = ("le", "Bonjour", "monde")
Entrée 27 : print(mots[ ?] + ", " + mots[ ?] + " " + mots[ ?] + " !")
Les tableaux
ATTENTION : Dans la suite nous allons employer le terme "tableau". Pour parler de ces "tableaux" les
concepteurs de Python ont choisi d'utiliser le terme de "list" ("liste" en français). Par souci "d'universalité"
par rapport à d'autres langages de programmation, nous utiliserons le terme "tableau" à la place du terme
"list".

Il n'est pas possible de modifier un tuple après sa création (on parle d'objet "immutable"), si vous essayez
de modifier un tuple existant, l'interpréteur Python vous renverra une erreur. Les tableaux sont, comme
les tuples, des séquences, mais à la différence des tuples, ils sont modifiables (on parle d'objets
"mutables").
Pour créer un tableau, il existe différentes méthodes : une de ces méthodes ressemble beaucoup à la
création d'un tuple :
mon_taleau[5, 8, 3, 7]
Notez la présence des crochets [ ] (à la place des parenthèses pour les tuples).
Un tableau est une séquence, il est donc possible de "récupérer" un élément d'un tableau à l'aide de son
20/36
indice (de la même manière que pour un tuple) : mon_tableau[i]
Un tableau étant modifiable, il est possible de modifier un tableau en changeant par exemple la valeur de
l'un de ses éléments désigné avec la notation "entre crochets".
Modifier le programme ci-dessous pour changer le tableau initial en [3, 6, 5, 9] :

Entrée 28 : mon_tableau = []
print(mon_tableau)
opérations sur les tableaux : append , del et len
 On peut ajouter un élément à la fin d'un tableau existant avec la méthode append:
mon_tableau.append(valeur_a_ajouter)
 On peut supprimer un élément d'un tableau avec l'instruction del (pour l'anglais delete), en
précisant l'indice i de l'élément à supprimer :
del mon_tableau[i]
 On peut connaître la taille d'un tableau (= le nombre d'éléments contenus dans le tableau) avec
l'instruction len (de l'anglais "length") :
len mon_tableau
Modifier le tableau initial pour arriver à [1, 3, 5, 7, 9], et vérifier que votre tableau final contient bien 5
éléments.
Entrée 29 :
Une petite parenthèse : on pourrait s'interroger sur l'intérêt d'utiliser un tuple puisque le tableau permet
plus de choses!

La réponse est simple : les opérations sur les tuples sont plus "rapides".
Quand vous savez que votre tableau ne sera pas modifié (cas d'un relevé de valeurs par exemple), il est
préférable d'utiliser un tuple à la place d'un tableau.
La boucle "for ... in ..." : parcourir les éléments d'un tableau
La boucle for ... in ...permet de parcourir chacun des éléments d’une séquence (tableau ou tuple) : testez
donc le code suivant :
monTableau = [3, 7, 12, 98]
Entrée 30 : for element in monTableau :
print(element)
21/36
Quelques explications : comme son nom l'indique, la boucle "for" est une boucle !
Nous "sortirons" de la boucle une fois que tous les éléments du tableau mon_tab auront été parcourus.
Elément est une variable qui va :
 au premier tour de boucle, référencer le premier élément du tableau (l'entier 3)

 au deuxième tour de boucle, référencer le deuxième élément du tableau (l'entier 7)
 au troisième tour de boucle, référencer le troisième élément du tableau (l'entier 12)
 au quatrième tour de boucle, référencer le quatrième élément du tableau (l'entier 98)
Une chose importante à bien comprendre : le choix du nom de la variable qui va référencer les éléments
du tableau les uns après les autres (élément) est totalement arbitraire, il est possible de choisir un autre
nom sans aucun problème, le code suivant donne exactement le même résultat :
monTableau = [3, 7, 12, 98]
Entrée 31 : for toto in monTableau :
print(toto)
La fonction range()
Dans la boucle for... in..., il est possible d’utiliser la fonction prédéfinie range() à la place d’un tableau
d’entiers, comme dans le code ci-dessous :
for element in range(0, 5) :
Entrée 32 : print (element)
Comme vous pouvez le constater, range(0,5) est, au niveau de la boucle "for..in", équivalent au tableau
[0,1,2,3,4]

ATTENTION : si vous avez dans un programme range(a,b), a est la borne inférieure et b la borne
supérieure. Vous ne devez surtout pas perdre de vu que la borne inférieure est incluse, mais que la borne
supérieure est exclue.
Ecrire un bout de code "générateur de punition" (50 fois "je ne dois pas utiliser que la boucle while") en
utilisant cette fois une boucle for... in...
Entré
e 33 : Tester ce code sur https://repl.it/languages/python3
22/36
Il est possible d'utiliser la méthode "range()" pour "remplir" un tableau. Créer les tableaux [0, 1, 2, 3, 4, 5,
6] et [0, 2, 4, 6, 8, 10, 12] en utilisant range(). Testez le programme suivant :
tableau1= []
Entrée 34 : tableau2= []
for i in range(7):
tableau1.append(i)
tableau2.append(i*2)
print(tableau1)
print(tableau2)
Créer un tableau par compréhension
Pour créer un tableau on peut donc par exemple :
 renseigner son contenu "à la main" :
mon_tab = [5, 8, 6, 9]
 utiliser la fonction append dans une boucle, comme ici :
Entrée 35 : mon_tableau = []

for element in range(0, 5):
mon_tableau.append(3* element)
print(mon_tableau)

Il est aussi possible d'obtenir exactement le même résultat que ci-dessus en une seule ligne grâce à la
compréhension de tableau, qui utilise une boucle for.. in... directement dans la structure en crochets du
tableau [...] :
mon_tab = [3*p for p in range(0, 5)]
Proposer une façon de générer le tableau [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024] en une ligne par
compréhension :
Entr
ée
36 :
Les compréhensions de tableau permettent de construire un tableau à partir d'un tableau existant, voire
de rajouter une condition (if) : 23/36
En complétant le code ci-dessous, afficher quel est le contenu du tableau référencé par la variable
mon_tab après l'exécution du programme ci-dessous ?
Entrée 37 : l = [1, 7, 9, 15, 5, 20, 10, 8]
mon_tab = [2*p for p in l if p > 10]
Travailler sur des "tableaux de tableaux"
Chaque élément d'un tableau peut être un tableau, on parle de tableau de tableau.
Voici un exemple de tableau de tableau :
m = [[1, 3, 4], [5 ,6 ,8], [2, 1, 3], [7, 8, 15]]
Le premier élément du tableau ci-dessus est bien un tableau ([1, 3, 4]), le deuxième élément est aussi un
tableau ([5, 6, 8])...
Il est souvent plus pratique de présenter ces "tableaux de tableaux" comme suit :
m = [[1, 3, 4],
[5, 6, 8],
[2, 1, 3],
[7, 8, 15]]
Nous obtenons ainsi quelque chose qui ressemble beaucoup à un "objet mathématique" très utilisé : une
matrice.
Il est évidemment possible d'utiliser les indices de position avec ces "tableaux de tableaux". Pour cela nous
allons considérer notre tableau de tableaux comme une matrice, c'est à dire en utilisant les notions de
"ligne" et de "colonne". Dans la matrice ci-dessus :
En ce qui concerne les lignes :
 1, 3, 4 constituent la première ligne

 5, 6, 8 constituent la deuxième ligne
 2, 1, 3 constituent la troisième ligne
 7, 8, 15 constituent la quatrième ligne
En ce qui concerne les colonnes :
 1, 5, 2, 7 constituent la première colonne

 3, 6, 1, 8 constituent la deuxième colonne
 4, 8, 3, 15 constituent la troisième colonne
Pour cibler un élément particulier de la matrice, on utilise la notation avec "doubles crochets" : m[ligne]
[colonne] (sans perdre de vue que la première ligne et la première colonne ont pour indice 0)
Dans le tableau m ci-dessous,

24/36
 combien vaut l’élément[1][2] ?
 quel élément vaut 7 ?
Entrée 38 : m = [[1, 3, 4], Faites le test dans un programme :

[5, 6, 8],
[2, 1, 3],
[7, 8, 15]]
Résultat attendu : 8
print(m[1][2]) Nous obtenons :8
Nota Bene : les valeurs d'un tableau de tableaux construit à partir de tableaux sont modifiées lors de la
modification du tableau utilisé pour le construire.
Vous n'avez pas compris la phrase précédente ?? moi non plus en fait... espérons que l'exemple vous
parlera mieux :
Entrée 39 : m = [1, 2, 3]

mm = [m, m, m]
print(mm) [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
m[0] = 4
print(mm) [[4, 2, 3], [4, 2, 3], [4, 2, 3]]
Comme vous pouvez le constater, la modification du tableau référencé par la variable m entraine la
modification du tableau référencé par la variable mm (alors que nous n'avons pas directement modifié le
tableau référencé par mm).
Il faut donc être très prudent lors de ce genre de manipulation afin d'éviter des modifications non désirées.
Parcourir un tableau de tableaux
Cela devra se faire avec une "double boucle for... in ..." : essayez d'écrire un bout de code affichant un à un
tous les éléments du tableau suivant :

Entrée 40 : m = [[1, 3, 4],
[5, 6, 8],
[2, 1, 3],
[7, 8, 15]]
for
25/36

10. Lire un fichier
Il est possible en Python de lire le contenu d'un fichier externe.
Avec l'exemple d'un fichier texte fichier1.txt, présent dans le même répertoire que ce tutoriel, nous allons
récupérer le contenu de ce fichier pour l'utiliser dans un programme python.
On ouvre le fichier avec la méthode open() selon la syntaxe suivante :
with open('nomDuFichier', 'r') as fichier :
Cette méthode prend 2 paramètres :

26/36
 le nom du fichier à ouvrir (avec son chemin relatif au script python)
 le mode d'ouverture : ici r pour read, le fichier est ouvert en mode lecture
Dans la suite du code le fichier ouvert est référencé par la variable fichier comme indiqué dans le code
... as fichier :
Il s'agit alors de lire le contenu de fichier avec la méthode read() en l'affectant à une variable de type
'chaîne de caractères' appelée contenu :
with open('nomDuFichier', 'r') as fichier :

contenu = fichier.read()
Affecter donc ci-dessous le contenu du fichier fichier1.txt à la variable contenu puis afficher le contenu de
cette variable :
Entrée 41 :
Le caractère "retour à la ligne", appelé caractère d'échappement est le caractère spécial : "\n".
On peut le supprimer en le remplaçant par une chaine vide avec la méthode replace() appliquée à une
chaîne de caractères selon la syntaxe suivante :
chaineDeCaracteres = contenu.replace("caractères à remplacer", "caractères à mettre à la place")
Testez donc l'exemple ci dessous pour comprendre la méthode replace()
Entrée 42 : maChaine = "Bonjour" Binjiur

maNouvelleChaine = maChaine.replace("o", "i")
print(maNouvelleChaine)
Ouvrez le fichier texte2.txt. Copier/coller son contenu ci contre :
Récupérer ci-dessous le contenu de texte2.txt expurgé de son caractère d'échappement :

Entrée 43 :
Il est possible de travailler avec un fichier texte contenant plusieurs lignes de données : le fichier
fichier3.txt contient plusieurs lignes de données (vous pouvez le vérifier en l'ouvrant dans un simple
éditeur de texte).
Il est alors possible de récupérer les données ligne par ligne à l'aide d'une boucle for :
with open('monGrandFichier.txt','r') as f :
for ligne in f: 27/36
print(ligne)
On notera qu'avec la boucle for, la méthode read() n'est plus utile.
Essayez de parcourir le fichier fichier3.txt ligne par ligne, en supprimant à chaque ligne les caractères de
retour à la ligne.
Entré
e 44:
Entré On vous donne le code suivant. Avec une boucle

e 45 : for…., modifier me afin d’obtenir le même
résultat que ci-dessus.
with open('../fichier3.txt','r') as f :
contenu=""
for ligne in f:
contenu=contenu+ligne.replace("/n","")
print(contenu)
Ranger les lignes d'un fichier dans un tableau
Quitte à faire, on peut stocker la succession d'informations que constituent les lignes d'un fichier dans un
tableau. C'est pratique pour s'y référer ou pour les parcourir par la suite.
Compléter le code ci-dessous pour qu'il fasse cela, et testez le :

Entrée 46 : # Créons le tableau vide "lesLignes"
lesLignes = []
# Ouvrons le fichier à lire
with open('fichier3.txt','r') as f :

# Parcourons le fichier ligne à ligne
for ligne in f:
# Supprimons les retours à la ligne
ligne=--------------------------
# Remplissons notre tableau avec la ligne en cours
---------------------------------------
# Affichons le contenu du tableau
print(-------------------------------------------------------------)
# On boucle sur le tableau
for i in -------------------------------:
# On affiche la ligne en cours
print(-------------)
28/36
Wowww ! Vous avez vu au dessus ? On peut parler tranquillement en français au milieu du code !!

11. Commenter son code
Le fait de commenter son code (dans n'importe quel langage de programmation) est une TRES TRES TRES
BONNE PRATIQUE à adopter lorsqu'on écrit un programme qui commence à faire plus de 10 lignes.
Les avantages sont cruciaux et innombrables :
 permet d'être au clair sur ce qu'on est en train de coder : si on sait exprimer clairement ce qu'on
attend de la ligne, de la fonction ou du bloc d'instructions, on a plus de chances de taper les
instructions de façons rigoureuse et précise et d'éviter des comportements non attendus du
29/36
programme (=bugs)
 permet de comprendre ce qu'on a voulu faire lorsqu'on réutilise un code qu'on a tapé la veille, ou la
semaine précédente, ou l'année dernière...
 permet aux autres qui voudront réutiliser mon code plus tard de s'y retrouver,
 etc.
La syntaxe est la suivante :

Entrée 47 :
# ceci est un commentaire d'une ligne, il commence par un dièse "#"
print("bonjour")
for i in range(1,5):
# Les commentaires peuvent ne pas être indentés dans le code
print(i)
# Mais c'est qd mm plus joli
print(i-1)
"""pour faire
un commentaire "multignes"
il doit être compris entre
3 guillemets (au début et à la fin)"""
# Allez, on s'arrête là
print("au revoir")

A retenir :
 commentaire sur une ligne : la ligne commence par #

 commentaire multi lignes : entre deux triples guillemets """ .... """
 en vrai, les triples guillemets servent à délimiter une chaine de caractères multilignes, mais sans
instructions, ils servent à faire office de commentaires.
Le code ci-dessous illustre le fait que ce qu'on vient de vous dire n'est pas faux :
Entrée 48 : # Ceci est un commentaire d'une ligne, il commence par un dièse "#"
print("Bonjour")
for i in range(1,5): 30/36

# Les commentaires peuvent ne pas être indentés dans le code
print(i)
# Mais c'est qd mm plus joli
print(i-1)
"""pour faire
un commentaire "multignes"
il doit être compris entre
3 guillemets (au début
et à la fin)"""
# Attention avec les triples guillemets

print("""les triples guillemets
permettent aussi de délimiter
des chaines de caractères
multilignes dans le code
lui-même""")
# Allez, on s'arrête là
print("au revoir")
Typiquement, il est plus facile de comprendre le code commenté ci-dessous et au passage de découvrir la
fonction input() qui permet à l'utilisateur de saisir une information, qui sera de type string (chaine de
caractères), que s'il avait été tapé sans aucuns commentaires :

Entrée 49 : # La fonction monMessage permet d'afficher un message
#****************début de la fonction monMessage******************

def monMessage(nom):
conCa="bonjour "+nom #conCa: concaténation de str
return conCa
#****************fin de la fonction monMessage********************
# Interrogation de l'utilisateur
monNom=input("Quel est votre nom ? ")
# Appel de la fonction monMessage
msg = monMessage(monNom)
# Affichage du message personnalisé de bienvenue 31/36
print(msg)
Python >= 3.5 # La fonction monMessage permet d'afficher un message
#****************Début de la fonction monMessage******************

def monMessage(nom):
return f"Bonjour {nom}"
#****************Fin de la fonction monMessage********************
# Interrogation de l'utilisateur
monNom=input("Quel est votre nom ? ")
# Appel de la fonction monMessage

msg = monMessage(monNom)
# Affichage du message personnalisé de bienvenue
print(msg)

12 Tracer des graphiques avec matplotlib
La librairie matplotlib permet de tracer "facilement" des graphiques (courbes, histogrammes, camemberts,
surfaces, etc.)
Elle est importée ci dessous via le module pylab, qui ramène en même temps numpy et math...
Pour installer un module Python, sous EduPython, faire :
32/36
Choix 2, saisir nom du module : pylab. Le module s’installe.
Trouver une multitude d’exemples d'utilisations et tutoriels sur le web, par exemple un en français ici:
https://python.doctor/page-creer-graphiques-scientifiques-python-apprendre
Le principe de base est de créer 2 tableaux contenant pour l'un les valeurs des abscisses et pour l'autre
celles des ordonnées.
Dans l'exemple ci dessous, le temps est en abscisse dans un tableau "t", l'ordonnée est calculée dans le
tableau "s" :

Entrée 50 : # ----- Courbe sinusoïdale ----
# On import le module pylab (donc la lib math)
from pylab import *
# On construit un tableau de 1000 points

compris entre 0 et 10
t = linspace(0.0, 10.0, 1000)
# On calcule nos 1000 valeurs de sinus

s = 3*sin(2.5*pi*t)
# On trace la courbe
plot(t, s) 33/36
# On labellise les axes et le graphique

xlabel('time (s)')
ylabel('voltage (mV)')
title('Sine Wave')
grid(True) #Affichage du quadrillage
# On affiche le tout
show()

Exemple : trajectoire d'on objet en chute libre
Dans cet exemple les modules matplotlib et numpy sont importés séparément...
Ici, le temps est en paramètre, "x" et "y" sont des fonctions de t :
Entrée 51 : # --- Chute libre --
# Importation module "plot"

import matplotlib.pyplot as plt
# Importation module "numpy" 34/36

import numpy as np
# Tableau de 1000 pts entre 0 et 10

t = np.linspace(0,10,1000)
# Conditions initiales
g = -9.81
x0 = 0
y0 = 0
vx0 = 5
vy0 = 50
# Calcul des positions en fct du tps

x = vx0 * t + x0
y = 0.5*g*t**2 + vy0 * t + y0
"""On trace et on labellise les axes

et le graphique"""
plt.xlabel('x en (m)')
plt.ylabel('y en (m)')
plt.title('y=f(x)')
plt.grid()
plt.plot(x,y)
plt.show()
Nous arrêterons là pour les graphismes de Python car ce chapitre est très vaste. A vous de trouver les réponses à vos
questions.

13. Un petit projet
Et voilà, vous savez maintenant faire déjà pas mal de choses avec python. L'idée maintenant est de lancer
un petit projet de code : écrire de A à Z un programme.
Les thèmes peuvent être nombreux (scientifiques, ludiques...), je vous propose de partir sur un petit jeu.
Voici deux petits jeux assez simples :
 le programme choisit au hasard un nombre entre 0 et 100, vous devez le retrouver en faisant des
propositions de nombres avec un retour "trop grand" ou "trop petit"
35/36
 faire un jeu de chi-fou-mi : l'utilisateur rentre un choix entre "papier", "caillou" ou "ciseau",
l'ordinateur choisit également et donne le résultat "victoire/nul/défaite" et compte les points : le
premier à 3 gagne la partie,
 un lien vers la page de documentation de la fonction random(), qui sert à tirer un nombre au hasard
: https://docs.python.org/3/library/random.html
IDE : spyder, eduPython ou autres
Vous pouvez faire ce projet en utilisant un environnement de programmation python, il en existe des tas, à
choisir parmi ceux installés dans votre établissement :
 spyder, fourni avec anaconda ou installable à part,

 eduPython, existe en version portable, qui n'a pas besoin d'être installé avec des droits
administrateur,
 plein d'autres...
Conseils généraux d'organisation et de bonnes pratiques pour coder efficacement :
 il est intéressant avant de se lancer dans le code de dresser un tableau récapitulatif des variables
dont on pense avoir besoin dans le programme en précisant : nom, type, description pour chaque
variable
 donnez des noms EXPLICITES à vos variables : s'il peut sembler un gain de temps de nommer ses
variables avec un nom vite tapé a, b, c, etc., il est bien plus compréhensible à terme de savoir à quoi
correspond une variable pointsDeVie, motMystere, lettresDejaProposees, etc. Le temps passé à
taper ces noms à rallonge est bien vite rattrapé lorsqu'il s'agit de relire et débuguer son code.
 pensez à régulièrement commenter votre code : au bout d'un certain nombre de ligne de codes, les
commentaires aident réellement à se repérer dans son code pour débusquer les éventuelles
erreurs,
 il peut être intéressant de découper son code en différentes fonctions chargées chacune de tâches
courtes bien définies plutôt que de se lancer dans une longue suite d'instructions sans fin qui
deviendra vite difficilement illisible.
Bon courage, rigueur, patience, méthode et plaisir !

14. Et pour aller plus loin sur magistère
Des formations de qualité et exhaustives sont disponibles sur magistère :
 formation python adaptée au programme de maths du lycée :

https://magistere.education.fr/ac-paris/course/view.php?id=4135&section=1
 formation python adaptée au programme de ScPhy au lycée:
https://magistere.education.fr/dgesco/course/view.php?id=1936
36/36

Inititiation À Python

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Inititiation À Python

Transféré par

Droits d'auteur :

Formats disponibles

Python - Une initiation en 13 étapes

Programmer un ordinateur, c'est quoi ?

Il existe 2 grandes familles de langages de programmation :

Lycée Saint Marc, Nivolas Vermelle Initiation à Python Tsi 2019-2020

Lancez EDUPYTHON Barres de menus et d’outils

Pour vous repérez ...

Zone de saisie du code

Dans la console saisissez la commande : print("Bonjour the world")

Définition du mot ordinateur d'après "Le Petit Larousse" :

Alors, qu'est-ce qu'une variable ?

Lycée Saint Marc, Nivolas Vermelle Initiation à Python Tsi 2019-2020

Une variable est donc constituée de 2 choses :

NB : Mais si la réponse est '42', quelle était la question ???...

Écrire un programme dans lequel on attribue la valeur 12 à la variable points_de_force. La valeur

Affichage du résultat dans la CEP

Lycée Saint Marc, Nivolas Vermelle Initiation à Python Tsi 2019-2020

Entrée 4 : type(points_de_vie)

Entrée 5 : type(environPi)

L'écriture a**b signifie "a à la puissance b"

Essayez d'écrire un programme qui additionnera le contenu de 2 variables appelées a et b. Le résultat de

Lycée Saint Marc, Nivolas Vermelle Initiation à Python Tsi 2019-2020

est tout à fait correct.

D'ailleurs quel est son résultat ? tester le code 5/36

On a affecté à a le résultat de l'addition a+42

Exposant, racine carrée, fonctions trigonométriques : appel à un module

Voici quelques exemples :

 math.pow(x,a) permet de calculer x à la puissance a

Saurez-vous faire un programme qui puisse afficher :

Lycée Saint Marc, Nivolas Vermelle Initiation à Python Tsi 2019-2020

Lycée Saint Marc, Nivolas Vermelle Initiation à Python Tsi 2019-2020

Wikipédia nous dit que :

L'opérateur utilisé pour concaténer deux chaines est le signe "+".

Lycée Saint Marc, Nivolas Vermelle Initiation à Python Tsi 2019-2020

Chaînes de caractères et variables

Lycée Saint Marc, Nivolas Vermelle Initiation à Python Tsi 2019-2020

Lycée Saint Marc, Nivolas Vermelle Initiation à Python Tsi 2019-2020

 la présence du f avant la chaine de caractères

Essayez donc d'afficher le décompte des manifestants avec cette méthode :

Entré Tester votre code sur https://repl.it/languages/python3

La notion de fonction en informatique est comparable à la notion de fonction en mathématiques.

Exemple : pour x = 4 , y = 14 (y = 3*4 + 2 = 14).

La fonction en informatique est basée sur la même idée :

Lycée Saint Marc, Nivolas Vermelle Initiation à Python Tsi 2019-2020

La fonction renvoie la valeur contenue dans la variable y.

Dans l'exemple ci-dessus : 11/36

Essayez donc ci-dessous de coder une fonction :

qui s'appelle : ma_fonction ,

qui prenne un paramètre appelé x,

qui renvoie la valeur y : y = 3.x + 2

Lycée Saint Marc, Nivolas Vermelle Initiation à Python Tsi 2019-2020

Entré Tester votre code sur https://repl.it/languages/python3

6. Les expressions et les booléens

Notez bien le double signe égal !!

Une expression peut soit être vraie (True), soit fausse (False)

Entrée 16 : CEP : 20==20  True

Lycée Saint Marc, Nivolas Vermelle Initiation à Python Tsi 2019-2020

Déduire du programme suivant, la signification de l'opérateur "!=" saisir et tester...

Entrée 18 : a=6

 « != » signifie « non égal à »

Exemples d'opérateurs de comparaison :

 == : "égal à"

Sa syntaxe en python est la suivante :

faire des choses

#début de la fonction monMessage**