Chapitre 0 - Introduction à Python

0.0 - Petite présentation

Communiquer avec un ordinateur demande un langage particulier : un langage de

programmation (Scratch, Python, etc.). Il utilise un ensemble de mots (instructions) et de
règles (syntaxe) et forme des programmes informatiques.

Un programme est un
ensemble d’opérations
destinées à être effectuées
par l’ordinateur.

Une instruction correspond à une action.

0.1 - Notion de variable

●​ Première partie :
Testez les variables par vous même !

Une variable en informatique permet de garder en mémoire (le temps que le programme
s'exécute) des données comme par exemple le résultat d'un calcul ou un mot, une liste ou
bien d'autres choses. Pour stocker en mémoire (je rappelle que l’expression correcte est que
“la valeur est affectée à la variable”) une valeur dans une variable, on utilise simplement le
signe égal =.
 Par exemple :​
a=3​
b=7​
c=b+a+2

Dans cet exemple, on a mis en mémoire 3 variables. Dans a, on a stocké la valeur 3, dans b
la valeur 7 et dans c la valeur 12.

Remarque importante : ce qui est stocké est le résultat du calcul et non le calcul.​
​
Ce qui veut dire que si on modifie la valeur de a, la variable c changera aussi.​
Pour afficher la valeur d'une variable, on utilise la fonction print​
​
Appuyez sur le bouton Run pour voir l'effet du code ci-dessous :​

[Link]

Petite subtilité avec les variables : On peut utiliser une certaine variable a pour faire un calcul
et stocker la réponse de nouveau dans a ce qui aura pour effet de faire disparaître la première
valeur de a. C'est très pratique pour éviter d'utiliser trop de variables différentes par exemple.
Petite explication des résultats affichés :

Au début a vaut 3, on lui ajoute 2 et on stocke dans a donc maintenant a vaut 5, ce qu'on
affiche en premier. Ensuite on calcule a+a donc 5+5=10 qu'on stocke de nouveau dans a, d'où
l'affichage du 10 en deuxième.

Une variable peut contenir des valeurs de différents types comme :

– des nombres entiers (int) ;

– des nombres décimaux, appelés aussi « flottants » (float) ;

– des textes, appelés « chaînes de caractères » (str).

 ●​ Deuxième partie :

Les opérations sur les variables numériques

Il y a bien sur les quatre opérations classiques +, -, *, / avec les priorités opératoires
habituelles.
Par exemple :
​

Les deux autres opérations que l’on utilise couramment sont les puissances et la racine
carrée. Pour les puissances, on double simplement la multiplication. Ainsi xn s'obtiendra en
écrivant x**n. Pour la racine carrée, on va simplement utiliser une propriété mathématique :
√x=x à la puissance 0.5. Donc pour calculer la racine carrée d'un nombre x, il suffit d'écrire
x**0.5.
Voici quelques exemples.

On a rajouté des commentaires à côté des instructions d'affichage des calculs pour que ces
instructions soient plus claires. Pour écrire un commentaire, il suffit de mettre un # devant.
Tout ce qui suit le # ne sera pas exécuté par l'ordinateur et ne sert donc qu'à la personne qui
lit le programme.
On peut aussi réaliser facilement des divisions euclidiennes (c'est à dire les divisions
posées comme au primaire). Pour obtenir le quotient de la division de a par b, il suffit d'écrire
a//b. Pour obtenir le reste de la division de a par b, il suffit d'écrire a%b. Remarque : La
différence entre a/b et a//b est que le premier donne une valeur approchée décimale à 16
chiffres après la virgule alors que la deuxième nous donne l'entier q tel que 0 <= a-bq < b.
Voici quelques exemples que vous pouvez modifier pour vérifier que vous avez bien compris.

Remarque : Même si ces opérations sont finalement assez peu utilisées en cours de
mathématiques, elles le sont beaucoup plus en informatique, principalement le calcul du
reste de la division euclidienne. Par exemple, pour déterminer si un nombre est pair, il suffit de
regarder si x%2 vaut 0. En effet, un nombre est pair si et seulement si son reste par la division
par 2 est nul. On l'utilisera régulièrement dans les exercices.
 ●​ Troisième partie :

Les instructions d’entrée et de sortie

Une instruction d’entrée permet à un programme de lire des valeurs saisies au clavier par
l’utilisateur. Une instruction de sortie affiche les valeurs de variables à l’écran. Nous avons
déjà utilisé l’instruction de sortie « print » qui permet d’afficher à l’écran la valeur des
variables.

En Python, l’instruction d’entrée « input » permet d’affecter la valeur saisie dans une
variable.

L’instruction « input » permet d’obtenir des chaînes de caractères. Si on veut saisir un entier,
il faut alors utiliser en plus l’instruction « int ».

L’instruction principale de sortie est print qui permet d’afficher surtout des chaînes de
caractères.
Cependant, comme pour l’instruction input(), si on lui demande d’afficher un entier, il va
automatiquement convertir l’entier en chaîne de caractères pour pouvoir l’afficher.

A noter que l’instruction print provoque un saut de ligne (comportement par défaut). Pour
écrire une suite de chaînes de caractères, on pourra utiliser la concaténation de chaînes en
utilisant l’opérateur « + ».
0.2 - Tests et conditions

Première partie : La structure IF ... ELIF ... ELSE

Quand on programme, il est indispensable de pouvoir expliquer à notre cher

ordinateur quoi faire selon les cas qu'il va rencontrer. C'est là qu'entre en jeu la
structure if... else....

"if" veut dire "si" et "else" veut dire "sinon". Une fois qu'on sait ça, la structure
devient assez intuitive, mais il reste à respecter une certaine syntaxe.

Commençons par la structure la plus simple :​ if

tout seul. Elle va nous permettre d'expliquer ce qu'il faut faire si une condition est vérifiée.
Décortiquons un exemple de cette partie de code (on suppose qu'il y a du code avant où on
obtient la valeur de la variable “note” ):
if note>15 :

print("Très Bien !")

Dans la première ligne on pourrait traduire le "if" par "si" et l'indispensable ":" en fin de ligne
par "faire" ce qui donnerait "Si note>15 faire".

L'ordinateur comprend alors qu'il doit faire ce qui suit seulement si la note est supérieure à 15.
Plus précisément, il ne va pas faire tout ce qui suit mais seulement ce qui est écrit en décalé (on
dit que le texte est indenté). C'est pour cela que print n'est pas écrit au même niveau que if.
Pour indenter, on utilise la touche tabulation.

Pour résumer notre exemple, si la note obtenue est par exemple 19, le programme affichera
“Très Bien !”

. Si on obtient la note 15 il ne fera rien.

IF... ELSE
Étoffons notre exemple en rajoutant ce qu'il doit afficher si la note n'est pas supérieure à 16.

if note>15 :

print("Très Bien !")

else :

print("Tu devras recopier 3 fois toutes les décimales de pi !")

Comme pour tout à l'heure, on peut traduire "else" par "sinon" et le ":" par "faire".
L'ordinateur comprend alors que si la condition note>16 n'est pas vérifiée alors il exécutera ce
qui est indenté en dessous de else.

Pour résumer notre exemple, si la note obtenue est par exemple 19, le programme affichera
“Très Bien !”

Si on obtient la note 15 ou 3, il affichera: “Tu devras recopier 3 fois toutes les décimales de pi !”

IF... ELIF ... ELSE

On comprend bien sur notre exemple qu'il faudrait rajouter davantage de conditions selon la
valeur de la note pour afficher des commentaires plus pertinents. Pour cela, on va utiliser
l'instruction intermédiaire elif qui est une contraction de else et if c'est à dire qu'on peut le
traduire par "sinon si". Il va nous permettre d'enchaîner les distinctions de cas. On peut en mettre
autant que l'on veut.

if note>15 :

print("Très Bien !")

elif note>13 :

print("Bien")

elif note>11 :

print("Assez Bien")

elif note>20 :

print("Tu es un génie !!!")

else :

print("Tu devras recopier 3 fois toutes les décimales de pi !")

Remarque : Pour le premier elif, je n'ai pas besoin de vérifier que la note est en dessous de 16
car si ce n'était pas le cas il aurait affiché "Très Bien !" et serait passé directement à la suite du
else sans regarder les autres conditions.

C'est pour cette même raison que "Tu es un génie" ne pourra jamais s'afficher car si la note
est par exemple 22, on a note>15 et donc il s'affichera "Très Bien !" et c'est tout.
Pour résumer notre exemple : Quand le programme s'exécute et tombe sur un if il va chercher
dans la série de conditions la première qui est validée et exécuter la partie du programme qui
correspond puis va sauter directement après le bloc de conditions sans examiner les autres.

TESTEZ CE QUE VOUS VENEZ D'APPRENDRE...

Voici le code précédent que vous pouvez tester et modifier pour bien comprendre comment cela
fonctionne. Essayez de deviner le résultat qu'on devrait obtenir pour des valeurs de note comme
17, 14, 10, 7 ou 21 puis vérifier en modifiant la valeur de note et en appuyant sur Run.
Deuxième partie : Les conditions

Après un if ou un elif, on a dit qu'il fallait mettre une condition. Une condition est tout
simplement quelque chose qui peut être vrai ou faux. Voici quelques exemples de conditions
qu'on complétera au besoin.

●​ True et False:​
Ils signifient vrai et faux donc ce sont les conditions les plus évidentes. On les
appelle les booléens. Il peut paraître absurde de mettre un booléen directement
après un if (puisque si on met True, le code correspondant sera toujours exécuté
donc le if ne sert à rien et inversement pour le False) mais dans la pratique, le
booléen sera dans une variable qui elle pourra être modifiée et donc selon la valeur,
l'action à effectuer ne sera pas la même.

●​ Les comparaisons :​
Une façon d'obtenir un booléen est en comparant deux objets comme on a fait avec
notre note dans la partie précédente. Voici les notations pour pouvoir comparer :​
== : pour tester l'égalité. Il faut doubler le = pour le différencier de l'affectation des
variables.​
!= : différent de.​
< : strictement inférieur.​
<= : inférieur ou égal.​
> : strictement supérieur.​
>= : supérieur ou égal.​

Par exemple :​ 1+1 == 2 est vrai.​

​ ​ 2*3 == 3 est faux.​
​ ​ 2+3 != 4 est vrai.​
​ ​ 14 >= 15 est faux.​

Les inégalités ne fonctionnent pas que pour les nombres. Par exemple, on peut
comparer des mots ou des listes de nombres avec l'ordre lexicographique (celui du
dictionnaire).​
​ "elephant" < "souris" est vrai​
​ "français" < "mathématiques" est vrai​
​ (1,5)<(2,3) est vrai
 ●​ Les connecteurs logiques not and et or :​
Ils permettent de créer une condition à partir d'autres conditions. Il en existe d'autres
mais ce sont les principaux. Si on les traduit, ça donnerait "contraire de" pour not,
"et" pour and et "ou" pour or. Par exemple :​
​
not x<3 est identique à x>=3.​
x<3 and x>1 est identique à 1<x<3 car x doit vérifier les deux conditions en
même temps.​
x<3 or x>5 est identique... à elle même car il n'y a pas de façon plus concise de
l'écrire. Elle sera vraie si une des deux conditions est vérifiée.

Créer un programme qui:

●​ Détermine la nature d’un triangle en fonction des 3 mesures de ses côtés

●​ Spécifie le parcours à suivre en cas d’alarme d’urgence en fonction de la salle que l’on
occupe.
0.3 - Les Boucles
La boucle for énumère les éléments d'un ensemble et pour chaque élément, répète toujours le
même code en fonction de cet élément. Donnons un exemple :

for objet in liste_courses :

trouver(objet)

mettre_dans_le_chariot(objet)

aller_payer()

Détaillons un peu. Pour chaque objet dans ma liste de courses, je fais toujours la même chose :
je le trouve puis je le mets dans le chariot. C'est ça que fait ma boucle for. Quand il n'y a plus
d'objet dans ma liste de course, je vais payer.

Attention au fait que, comme pour le if... else..., il ne faut pas oublier les ":" en fin de
ligne et, de plus, ce qui doit être fait en boucle doit être indenté. Et le aller_payer
n'est pas indenté car je ne paye qu'à la fin. S'il était indenté, cela signifierait que pour chaque
objet j'irais payer avant de passer à l'objet suivant...

Passons à des exemples plus informatiques.

Nous allons nous intéresser principalement à l'énumération de nombres car c'est de loin la plus
utile au début. Pour créer une liste de nombres, on utilise la fonction range.

●​ range(n): crée une liste de n nombres allant de 0 à n-1.​

Et oui en informatique, il va falloir prendre l'habitude de toujours commencer à 0 et
du coup finir à n-1 si on veut n nombres en tout.

●​ range(n1,n2): crée une liste de nombres allant de n1 à n2-1.

●​ range(n1,n2,pas): crée une liste de nombres allant de n1 à n2-1 en sautant de

pas en pas.

Par exemple :

●​ range(4)​
est la suite de nombres 0 1 2 3

●​ range(3,6)​
est la suite de nombres 3 4 5

●​ range(1,9,3)​
est la suite de nombres 1 4 7 (de 3 en 3 en partant de 1)
 ●​ range(3,0,-1)​
est la suite 3 2 1 (un pas négatif permet de compter à l'envers ce qui est très
pratique des fois)

Passons à des exemples d'utilisation. Essayez d'abord de deviner le résultat puis appuyez sur
Run pour vérifier.
0.4 - Les Modules
Présentation:

Python possède certaines fonctions de bases prédéfinies comme input(), print(), range(), .. Mais
selon les sujets étudiés, d'autres fonctions plus spécialisées s’avéreront nécessaires.

Elles sont regroupées en bibliothèques nommées modules :

●​ math (pour les calculs scientifiques)

●​ random (gestion du hasard)
●​ turtle ( dessins )
●​ tkinter ( Interface)
●​ time ( gestion du temps), etc ...

Il faudra les importer au cas par cas selon les besoins

Importation d'un module : retenez ces deux méthodes.

NB : Pour connaître le détail des fonctions d'un module on tape help("module") dans la console
python.

Conseils d'usage « from module import * » convient à un programme court et spécialisé. Le

script sera plus allégé. « import module » convient à un projet plus complexe ou général pour
éviter les conflits entre noms fonctions identiques. Enfin on peut importer un module d'une
manière, et un second d'une autre. On écrira l'une de ces instructions au tout début, ( première
ou deuxième ligne).

Ex1 : Module math

Ouvrir un nouveau script Python

1. Compléter la documentation ci-contre par les noms des instructions Python trouvées avec
help en console.

from math import * """ Quelques fonctions Python

racine carré : ……sqrt()……….
partie entière : …………….
convertir radians en degrés : …………….
nom de la variable π : …………….
fonctions trigonométriques : ……………… …………….…………….…………….
2. ​ a) Faire un programme donnant la longueur de l’hypoténuse d'un triangle ABC rectangle
en A, après avoir demandé les longueurs des autres côtés.
b) Faire calculer et afficher les deux angles 𝐵̂ et Ĉ au degré près.
c) Pour les rapides. Afficher l'aire et le périmètre du cercle circonscrit

Ex2 : Module random

Voici deux fonctions du module random

randrange (a,b) Renvoie un entier aléatoire dans [a ; b[

random () Renvoie un flottant dans [0 ; 1[

Faire un programme simulant 20 lancers d'un dé à six faces. Afficher la liste des résultats.

Ex3 : Module time ( pour les rapides)

sleep(t) Effectue une pause de t secondes

time() Renvoie la date POSIX ( temps écoulé depuis

01/01/1970 en secondes).

localtime( ) Renvoie la structure de temps locale,

actuelle.

localtime().tm_mday (ou tm_mon, tm_year, Renvoie la variable numérique 'jour' de la

tm_hour, tm_min, tm_sec) structure de temps (ou le mois, l'année,
l'heure, les minutes, les secondes)

strftime( 'Il est %H heure ', localtime()) ( et Renvoie une chaîne de caractère , intégrant
aussi : %H %M %S %d %m %Y ) les éléments de la structure de temps
précédés de % . ( Heure, Minutes, secondes,
jours, mois, année,..)

Préambule : observez ce que donnent time() et localtime() avec la console de l'interpréteur.

Ex4 : Module turtle

Le module turtle de Python est un module éducatif qui permet d’apprendre la programmation en
créant facilement des **dessins graphiques**. Il s’inspire du langage **Logo**, où une « tortue »
virtuelle se déplace sur l’écran en suivant des instructions simples.

Principe de base
La « tortue » représente un curseur qui trace une ligne lorsqu’elle avance. On peut lui donner
des ordres comme :

* `forward(100)` → avancer de 100 unités

* `right(90)` → tourner à droite de 90°
* `penup()` / `pendown()` → lever ou baisser le stylo pour dessiner ou non

👉 **Exemple simple :**

Ce programme dessine un **carré**.

Voici une **liste d’une douzaine d’instructions utiles** du module `turtle`, avec des exemples
permettant de dessiner des formes plus complexes et d’introduire des notions géométriques
(angles, coordonnées, boucles, variables, fonctions…).

**Commandes de base**
Exemples intéressants

🔹 1. Polygone régulier (boucles et angles)

→ Permet de visualiser la relation angle/symétrie dans les polygones réguliers.

🔹 2. Cercle et arcs (notion de rayon)

🔹 3. Forme remplie (aire et couleur)

→ Intéressant pour aborder la **surface** et la **symétrie**.

🔹 4. Spirale (angles et boucles cumulatives)

→ Montre les effets d’un angle fixe et d’une distance croissante.

🔹 5. Rosace (boucles imbriquées)

→ Excellent pour introduire la **rotation autour d’un centre** et les

**fractales simples**.

🔹 6. Coordonnées cartésiennes (repérage dans le plan)

→ Permet de visualiser un **repère orthonormé**.

1. Faire un script qui affiche un compte à rebours des secondes à partir de 5, puis ' Prêt '
2. Compléter le script pour qu'il demande votre année de naissance. Ensuite il doit afficher ' On
est le…………à……………' avec la date et l'heure d'aujourd'hui, puis doit afficher 'Vous
avez…………ans ' avec votre âge .
3. Compléter le programme pour qu'il pose une question, puis si la réponse est juste affiche
'Gagné en ….secondes' avec le temps écoulé , sinon affiche 'Perdu'.
Ex5 : Mini projet 'Le juste prix'

1. Écrire un programme qui demande de trouver un prix ( entier) compris entre 30 et 100 €,
affiche « C'est plus » ou « C'est moins » jusqu'à ce que vous ayez « Gagné ! »
2. Afficher le nombre de coups au final.
3. Limiter à 10 coups, puis donner la réponse et préciser « Perdu ! » si en 10 essais on n'a pas
trouvé.
4. Commenter, et faites figurer des tests en fin de code.
Développements au choix pour les rapides :
5. Ajouter un code triche
6. Proposer de rejouer en fin de partie, comptabiliser les parties gagnées, ...
7. Faire des niveaux de difficulté croissante, ….
 Mise au point d'un programme

Le bug n'est pas un accident mais plutôt un état normal d’un système informatique et le
débogage est donc une phase incontournable. Voici un premier bilan des outils à votre
disposition.

- Commenter et documenter. Agit préventivement en facilitant la relecture.

- Tester votre programme. Choisir des cas particuliers ( 0, rien , …), ou dont le résultat est connu.
- Instrumenter votre programme. C'est à dire parsemer le programme d’« affichage test » de
variables ciblées. A effacer ou désactiver ensuite ( avec #) .
Simple mais efficace.

Idée : déclarer une variable debug=1 et faire précéder les «affichages test» par « if debug: »
Ainsi quand le programme est au point, affecter True à debug désactivera les « affichages tests
».
- Utiliser le débogueur. Les éditeurs possèdent
toujours ce type d'outil comme ici avec
EduPython. Première approche : tenter une
exécution pas à pas pour tenter de cerner le
problème.

Mettez en application ce que vous avez appris dans l'exercice suivant:

Vous avez 30 minutes pour choisir un de ces programmes à faire (la note sur 20 est limitée par
le niveau de difficulté en rouge:

1)​ Écrire un programme qui demande de trouver un prix (entier) compris entre 30 et 100 €,
affiche « C'est plus » ou « C'est moins » jusqu'à ce que vous ayez « Gagné ! » (sur 18)
Afficher le nombre de coups au final. (sur 20)

2)​ Faire un script qui affiche un compte à rebours des secondes à partir de 5, puis ' Prêt '
Compléter le script pour qu'il demande votre année de naissance, puis doit afficher 'Vous
avez…………ans ' avec votre âge . (sur 16)

3)​ Faire un script qui affiche ' On est le…………à……………' avec la date et l'heure
d'aujourd'hui, Compléter le programme pour qu'il pose une question, puis si la réponse est juste
affiche 'Gagné en ….secondes' avec le temps écoulé , sinon affiche 'Perdu'. (sur 20)

4)​ Faire un programme simulant 20 lancers d'un dé à six

faces. Afficher la liste des résultats. (sur 14)

5) ​ Faire un programme donnant la longueur de

l’hypoténuse d'un triangle ABC rectangle en A, après avoir
demandé les longueurs des autres côtés. (sur 12). Faire calculer et afficher les deux angles 𝐵̂ et
Ĉ au degré près.(sur 16). Afficher l'aire et le périmètre du cercle circonscrit (sur 20)
0.5 - Chaînes et codages

Première partie : Les chaînes de caractères

Présentation:​ Parmi les divers types de variables, voici le moment d'étudier de plus près le type
string, déjà rencontré par exemple pour afficher des messages (entre guillemets) avec la
fonction print.

Définition:​ Une donnée de type string ou « chaîne » est une suite ordonnée de caractères,
(lettres, chiffres ou symbole) délimitée par des apostrophes ou des guillemets.

Remarque:​ Les caractères d'une chaîne sont ordonnés. On peut les compter et les repérer
par leur rang (ou indice).

Premières fonctions:
​ ​ ​ len(ch) renvoie le nombre de caractères de la chaîne ch
​ ​ ​ ch[i] renvoie le caractère d’indice i de la chaîne ch
​ ​
Attention:​ Le premier indice est 0 donc le dernier est: len(ch) - 1
​ ​ Une chaîne n’est pas modifiable: ch[i]=a
​
Ex1 : Vertical.

a) Faire un programme demandant un mot au clavier et le réécrit en revenant à la ligne à chaque

lettre.
b) Refaire une version avec la boucle non utilisée (while ou for)

Ex2 : Anticonstitutionnellement.

1. Dire ce que va faire le programme suivant . ​ mot='anticonstitutionnellement'

nb,i=0,0
while i<len(mot):
if mot[i] in('a','e','i','o','u','y' ):
nb=nb+1
i=i+1
print(mot,'à',nb,'voyelles')

2. Écrire un programme qui demande une lettre ( au clavier) et donne le nombre de fois où elle
apparaît dans le mot « anticonstitutionnellement » .

Remarque
Modifier une chaîne existante n'est pas possible. Mais on peut contourner le problème en créant
une autre chaîne, à partir d'extraits appropriés de la première, concaténés ( accolés).
Opérations:

ch[deb : fin] donne l'extrait de ch, du caractère d'indice deb à celui d'indice fin-1.
ch1 + ch2 concatène les chaînes ch1 et ch2. Ex : "bon"+"jour" donne "bonjour"
ch ∗ n répète n fois la chaîne ch. Ex : "ha ! "*3 donne "ha ! ha ! Ha ! "
[Link](), [Link]() renvoient respectivement la chaîne ch en majuscules et en minuscules

Ex3 : Astérisque.

Écrire un programme demandant une chaîne, pour en afficher une copie modifiée avec des
astérisques entre les caractères. Ainsi par exemple, « gaston » devra devenir « g*a*s*t*o*n »

Ex4 : Glouglou.

Écrire un programme qui double toutes les voyelles d'une phrase par exemple :''allez toulon''
devient ''aalleez toouuloon''

Ex5 : Palindrome (pour les rapides)

Un palindrome est un mot ou une phrase dont l’ordre des lettres reste le même si on le lit de
gauche à droite ou de droite à gauche. Par exemple, « bob », « radar », « ressasser » sont des
palindromes. Écrire un programme qui demande un mot, et dit ensuite si c'est un palindrome.

Rechercher et remplacer

- for car in ch : Boucle qui parcourt directement les caractères car d'une chaîne ch
- [Link](car) : renvoie le nombre de fois où le caractère car se trouve dans ch et -1 sinon
- 'car' in (ch) est un booléen qui vaut True si 'car' est dans la chaîne et False sinon.
- [Link] ('car1','car2') : Remplace 'car1' par 'car2' . A affecter dans une nouvelle chaîne

Ex6 : Pendu.

Programmer une esquisse d’un jeu du pendu qui demande à l'animateur d'entrer un mot dans le
programme, au joueur de proposer une lettre, et indiquant si cette lettre est présente (combien
de fois) ou pas dans le mot.

Ex7 : Scrabble et algorithme.

On veut programmer une esquisse d'un jeu de scrabble. Le programme doit demander au joueur
les 7 lettres correspondant au tirage de son jeu, demander sa proposition de mot, puis indiquer
s'il peut en effet former ce mot avec ces 7 lettres au maximum.
a) L'algorithme proposé ci-après contient une erreur. Débusquez la !

Pour les
rapides b)
Coder
l'algorithme
corrigé en
Python, et le
tester.
Deuxième partie : Codage des caractères
Le code ASCII (American Standard Code for Information Interchange) est une norme de codage
de caractère pour l'échange d'information, ayant permis l'échange de textes en anglais à un
niveau mondial.

Depuis l' UTF-8 l'a supplanté car conçu pour coder l’ensemble des caractères et alphabets du
monde ( accentuées, asiatiques, arabes, ..), tout en restant totalement compatible avec ce
standard.

• ord(car) : Renvoie le code ASCII du caractère car.

• chr(n) : Renvoie le caractère dont le code ASCII est n

Python comme tous les langages, permet d'obtenir le code ASCII de tout caractère et
inversement.

Cryptographie, Chiffrement.

Le chiffrement est un procédé de cryptographie pour rendre la compréhension d'un document

impossible à toute personne qui n'a pas la clé de déchiffrement.

Ex8 : Code César

Le code (ou chiffre) de César, utilisé au premier siècle, consiste à décaler l’alphabet d’un certain
nombre de lettres.
Par exemple avec un décalage de trois rangs : «MAYOTTE » devient « PDBRWWH»

1) Faire un programme qui demande une chaîne de caractères et le code selon cette méthode.
(On acceptera pour l'instant dans le message codé tous les types de caractères).

2) Comment faire pour déchiffrer un tel message code ?

3) Pour les rapides : message et message codé doivent être en majuscules.

Ex9 : Codage ROT13 (pour les rapides)

Le principe consiste à remplacer chaque lettre, par la lettre située 13 places plus loin dans
l'alphabet, en revenant à « A » après le « Z » (on fait une rotation de 13 places, d'où le nom).

1) Faire un programme qui demande une chaîne de caractères en majuscules (Sans caractères
spéciaux, espaces, accents) et la chiffre.
2) Comment fait-on pour décoder un message ainsi codé ? *.
0.6 - Listes et tableaux

Première partie : Listes

Imaginons que l’on veut garder nos résultats des derniers devoirs:

>>> maths = 17
>>> Franç = 18
>>> EPS = 20

Le problème maintenant apparaît si on a besoin de stocker un grand nombre de résultats

>>> Élève1maths1 = 18
>>> Élève2maths1 = 16
>>> Élève3maths1 = 12
>>> …

Présentation:​ Les listes (ou list / array ) en python sont une variable dans laquelle on peut
mettre plusieurs variables:

Créer une liste en python

Pour créer une liste , rien de plus simple:​ ​

>>> maths1= []

Vous pouvez voir le contenu de la liste en l'appelant comme ceci:

>>> maths1
<type 'list'>

Ajouter une valeur à une liste python

Vous pouvez ajouter les valeurs que vous voulez lors de la création de la liste python :

>>> liste = [1,2,3]

>>> liste
[1, 2, 3]

Ou les ajouter après la création de la liste avec la méthode append (qui signifie "ajouter" en
anglais):

>>> liste = []
>>> liste
[]
>>> [Link](1)
>>> liste
[1]
>>> [Link]("ok")
>>> liste
[1, 'ok']

On voit qu'il est possible de mélanger dans une même liste des variables de type
différent. On peut d'ailleurs mettre une liste dans une liste.

On peut afficher qu’un item d'une liste

Pour lire une liste, on peut demander à voir l'index de la valeur qui nous intéresse:

>>> liste = ["a","d","m"]

>>> liste[0]
'a'
>>> liste[2]
'm'

Le premier item commence toujours avec l'index 0. Pour lire la premier item on
utilise la valeur 0, le deuxième on utilise la valeur 1, etc.

Il est d'ailleurs possible de modifier une valeur avec son index

>>> liste = ["a","d","m"]

>>> liste[0]
'a'
>>> liste[2]
'm'
>>> liste[2] = "z"
>>> liste
['a', 'd', 'z']

Il est parfois nécessaire de supprimer une entrée de la liste. Pour cela vous pouvez utiliser
la fonction del .

>>> liste = ["a", "b", "c"]

>>> del liste[1]
>>> liste
['a', 'c']
Il est possible aussi de supprimer une entrée d'une liste avec sa valeur avec la méthode
remove .

>>> liste = ["a", "b", "c"]

>>> [Link]("a")
>>> liste
['b', 'c']

Vous pouvez inverser les items d'une liste avec la méthode reverse .

>>> liste = ["a", "b", "c"]

>>> [Link]()
>>> liste
['c', 'b', 'a']

Comme avec les chaînes il est possible de compter le nombre d'items d'une liste avec la
fonction len .

>>> liste = [1,2,3,5,10]

>>> len(liste)
5

Pour connaître le nombre d'occurences d'une valeur dans une liste, vous pouvez utiliser la
méthode count .

>>> liste = ["a","a","a","b","c","c"]

>>> [Link]("a")
3
>>> [Link]("c")
2

Et la méthode index vous permet de connaître la position de l'item cherché.

>>> liste = ["a","a","a","b","c","c"]

>>> [Link]("b")
3

Voici quelques astuces pour manipuler des listes:

>>> liste = [1, 500, 250, 100, 10]

>>> liste[0]
1
>>> liste[-1] # Cherche la dernière occurence
500
>>> liste[-4:] # Affiche les 4 dernières occurrences
[500, 250, 100, 10]
>>> liste[:] # Affiche toutes les occurences
[1, 10, 100, 250, 500]
>>> liste[2:4] = [69, 70]
[1, 10, 69, 70, 500]
>>> liste[:] = [] # vide la liste
[]

Pour afficher les valeurs d'une liste, on peut utiliser une boucle:

>>> liste = ["a","d","m"]

>>> for lettre in liste:
... print (lettre)
...
a
d
m

Si vous voulez en plus récupérer l'index, vous pouvez utiliser la fonction enumerate .

>>> for lettre in enumerate(liste):

... print (lettre)
...
(0, 'a')
(1, 'd')
(2, 'm')

Les valeurs retournées par la boucle sont des tuples.

Copier une liste

Beaucoup de débutants font l'erreur de copier une liste de cette manière

>>> x = [1,2,3]
>>> y = x

Or si vous changez une valeur de la liste y , la liste x sera elle aussi affectée par cette
modification:

>>> x = [1,2,3]
>>> y = x
>>> y[0] = 4
>>> x
[4, 2, 3]
En fait cette syntaxe permet de travailler sur un même élément nommé différemment

Alors comment copier une liste qui sera indépendante?

>>> x = [1,2,3]
>>> y = x[:]
>>> y[0] = 9
>>> x
[1, 2, 3]
>>> y
[9, 2, 3]

Pour des données plus complexes, vous pouvez utiliser la fonction deepcopy du module
copy

>>> import copy

>>> x = [[1,2], 2]
>>> y = [Link](x)
>>> y[1] = [1,2,3]
>>> x
[[1, 2], 2]
>>> y
[[1, 2], [1, 2, 3]]

Transformer une string en liste

Parfois il peut être utile de transformer une chaine de caractère en liste. Cela est possible
avec la méthode split .

>>> ma_chaine = "Olivier:ENGEL:Strasbourg"

>>> ma_chaine.split(":")
['Olivier', 'ENGEL', 'Strasbourg']

Et à l’envers, transformer une liste en string

L'inverse est possible avec la méthode " join ".

>>> liste = ["Olivier","ENGEL","Strasbourg"]

>>> ":".join(liste)
'Olivier:ENGEL:Strasbourg'
Trouver un item dans une liste

Pour savoir si un élément est dans une liste, vous pouvez utiliser le mot clé in de cette
manière:

>>> liste = [1,2,3,5,10]

>>> 3 in liste
True
>>> 11 in liste
False

Je rappelle que la fonction range génère une liste composée d'une simple suite
arithmétique.

>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Pour mettre bout à bout deux listes, vous pouvez utiliser la méthode extend

>>> x = [1, 2, 3, 4]
>>> y = [4, 5, 1, 0]
>>> [Link](y)
>>> print x
[1, 2, 3, 4, 4, 5, 1, 0]

Permutations

La permutation d'un ensemble d'éléments est une liste de tous les cas possibles. Si vous
avez besoin de cette fonctionnalité, inutile de réinventer la roue, itertools s'en occupe pour
vous.

>>> from itertools import permutations

>>> list(permutations(['a', 'b', 'c']))
[('a', 'b', 'c'), ('a', 'c', 'b'), ('b', 'a', 'c'), ('b', 'c', 'a'), ('c',
'a', 'b'), ('c', 'b', 'a')]

Permutation d'une liste de liste

Comment afficher tous les cas possibles d'une liste elle-même composée de liste? Avec
l'outil product de itertools :

>>> from itertools import product

>>> list(product(['a', 'b'], ['c', 'd']))
[('a', 'c'), ('a', 'd'), ('b', 'c'), ('b', 'd')]

Opérations et astuces

Afficher les 2 premiers éléments d'une liste

>>> liste = [1,2,3,4,5]

>>> liste[:2]
[1, 2]

Afficher le dernier item d'une liste:

>>> liste = [1, 2, 3, 4, 5, 6]

>>> liste[-1]
6

Afficher le 3ème élément en partant de la fin:

>>> liste = [1, 2, 3, 4, 5, 6]

>>> liste[-3]
4

Afficher les 3 derniers éléments d'une liste:

>>> liste = [1, 2, 3, 4, 5, 6]

>>> liste[-3:]
[4, 5, 6]

Vous pouvez additionner deux listes pour les combiner ensemble en utilisant l'opérateur + :

>>> x = [1, 2, 3]
>>> y = [4, 5, 6]
>>> x + y
[1, 2, 3, 4, 5, 6]

Vous pouvez même multiplier une liste:

>>> x = [1, 2]
>>> x*5
[1, 2, 1, 2, 1, 2, 1, 2, 1, 2]

Ce qui peut être utile pour initialiser une liste:

>>> [0] * 5

[0, 0, 0, 0, 0]
0.7 - Fonctions

Les fonctions sont les éléments structurants de base de tout langage procédural.

Elles offrent différents avantages :

●​ évitent la répétition : on peut « factoriser »

une portion de code qui se répète lors de
l'exécution en séquence d'un script ;

●​ mettent en relief les données et les résultats :

entrées et sorties de la fonction ;

●​ permettent la réutilisation : mécanisme de

l'import ;

●​ décomposent une tâche complexe en tâches

plus simples : conception de l'application.
Une fonction est un ensemble d'instructions regroupées sous un nom et s'exécutant à la demande

On doit définir une fonction à chaque fois qu'un bloc d'instructions se trouve à plusieurs reprises
dans le code ; il s'agit d'une « factorisation de code ».

La définition d'une fonction se compose :

●​ du mot clé def suivi de l'identificateur de la fonction, de parenthèses entourant les

paramètres de la fonction séparés par des virgules, et du caractère « deux-points » qui
termine toujours une instruction composée ;

●​ d'une chaîne de documentation (ou docstring) indentée comme le corps de la fonction ;

●​ du bloc d'instructions indenté par rapport à la ligne de définition, et qui constitue le corps de
la fonction.

Le bloc d'instructions est obligatoire. S'il est vide, on emploie l'instruction pass.

La documentation (“”” ou #), bien que facultative, est fortement conseillée.

def afficheAddMul(a, b) :
"""Calcule et affiche :
- la somme de a et b,
- le produit de a et b.
"""
somme = a + b
produit = a * b
print("La somme de", a, " et", b, " est", somme, "et le produit",
produit)

Exemple sans l'instruction return, ce qu'on appelle souvent une procédure. Dans ce cas la fonction
renvoie implicitement la valeur None :

def table(base, debut, fin) :

"""Affiche la table de multiplication des <base> de <debut> à <fin>."""
n = debut
while n <= fin :
print(n, 'x', base, '=', n * base)
n += 1

# exemple d'appel :
table(7, 2, 8)
# 2 x 7 = 14 3 x 7 = 21 4 x 7 = 28 5 x 7 = 35 6 x 7 = 42 7 x 7 = 49 8 x 7 =
56

# autre exemple du même appel, mais en nommant les paramètres ;

table(base=7, debut=2, fin=8)
Exemple avec utilisation d'un return unique :
from math import pi

def cube(x) :
"""Retourne le cube de l'argument."""
return x**3

def volumeSphere(r) :
"""Retourne le volume d'une sphère de rayon <r> ;"""
return 4.0 * pi * cube(r) / 3.0

# Saisie du rayon et affichage du volume

rayon = float(input('Rayon : '))
print("Volume de la sphère =", volumeSphere(rayon))

Puisqu'en Python une variable peut référencer une fonction, on peut transmettre une fonction
comme paramètre :

>>> def f(x):

... return 2*x+1
...
>>> def g(x):
... return x//2
...
>>> def h(fonc, x):
... return fonc(x)
...
>>> h(f, 3)
7
>>> h(g, 4)
2