PYTHON

L’histoire

Python est un langage de programmation, dont la première version est sortie

en 1991. Créé par Guido van Rossum, il a voyagé du Macintosh de son créateur,
qui travaillait à cette époque au Centrum voor Wiskunde en Informatica aux
Pays-Bas, jusqu’à se voir associer une association, la Python Software
Foundation , créée en 2001. Ce langage a été baptisé ainsi en hommage à la
troupe de comiques les « Monty Python ».

Un langage de programmation interprété

Python est un langage de programmation interprété, c'est-à-dire les

instructions que vous lui envoyez sont transcrites en langage machine au fur à
mesure de leur lecture. D’autres langages comme le C/C++ sont appelés
langages compilés car, avant de pouvoir les exécuter, un logiciel spécialisé se
charge de transformer le code du programme en langage machine. On appelle
cette étape la compilation. Les avantages d’un langage interprété sont la
simplicité et la portabilité c’est à dire il est censé de fonctionner aussi bien sous
windows que sous Linux.

A quoi peut servir Python ?

Il permet de créer toutes sortes de programme, comme des scripts, des jeux,
des logiciels, des progiciels…

Il est possible d’associer des bibliothèques à Python afin d’étendre ses

possibilités.

Installer Python

Quelque soit votre système d’exploitation, vous devez vous rendre sur le site
officiel de Python (python.org).

1. Cliquez sur le lien Download dans le menu principal de la page.

2. Sélectionnez la version de Python
3. Enregistrez puis exécutez le fichier d’installation et suivez les étapes.
4. Une fois l’installation terminée, vous pouvez vous rendre dans le menu
Démarrer, ouvrez l’application IDLE. Vous êtes prêts à coder.
 Chapitre 1 LES VARIABLES

Une variable est une donnée de votre programme, stockée dans votre
ordinateur. C’est un code alpha-numérique que vous allez lier à une donnée de
votre programme, afin de pouvoir l’utiliser à plusieurs reprises et faire des
calculs. En Python, pour donner une valeur à une variable , il suffit d’écrire
nom_de_la_variable=valeur , on appelle cette étape l’affectation de valeur à
une variable.

Les différents types de données

Les nombres entiers

Le type entier se nomme int en Python. La forme d’un entier est un nombre
sans virgule.

Les nombres flottants

Les flottants sont les nombres à virgule. Ils se nomment float en Python.

La syntaxe d’un nombre flottant est celle d’un nombre à virgule (n’oubliez pas
de remplacer la virgule par un point).

Les chaînes de caractères

Ce type de donnée permet de stocker une série de lettres. On peut écrire une
chaine de caractère entre guillemets.

Première utilisation des fonctions

Une fonction exécute un certain nombre d’instructions déjà enregistrées. Vous

n’avez qu’à appeler cette fonction par son nom autant de fois que nécessaire.

La plupart des fonctions ont besoin d’au moins un paramètre pour travailler sur
une donnée ; ces paramètres sont des informations que vous passez à la
fonction afin qu’elle travaille dessus.

Les fonctions s’utilisent en respectant la syntaxe suivante :

Nom_de_la_fonction (parapetre_1,parapmetre_2,…,parapetre_n)
La fonction type()

La syntaxe de cette fonction est simple :

type ( nom_de_la_variable)

La fonction renvoie le type de la variable passée en paramètre.

La fonction print()

La fonction print permet d’afficher la valeur d’une ou plusieurs variables.

Exemple :

a=3

print (a)

a=a+3

b=a-2

print (" a=", a , " et b= ", b )

Le premier appel à print affiche 3 , le second appel à print affiche : a=6 et 6=4

La fonction input ( )

input ( ) est une fonction qui va, pour nous, caractériser nos premières
interactions avec utilisateur : le programme réagira différemment en fonction
du nombre saisi par l’utilisateur.

Input ( ) accepte un paramètre facultatif : le message à afficher à l’utilisateur.

Cette instruction interrompt le programme et attend que l’utilisateur saisisse
ce qu’il veut puis appuie sur Entrée. A cet instant , la fonction renvoie ce que
l’utilisateur a saisi. Il faut donc affecter cette valeur dans une variable.

Exemple :

x= input (" Entrez votre année de naissance : ")

y= int (x)

print (" vous avez " , 2022-y , " ans ")

Exercices

1) Ecrire un programme qui demande à l’utilisateur d’entrer une base et un

nombre dans cette base et qui affiche ce nombre en base 10.
(indication : La fonction int ( chaîne,base ) permet de convertir une
chaîne représentant un entier dans une base donnée en un entier en
base 10.)
2) Ecrire un programme qui calcule les coordonnées du point d’intersection
de deux droites sécantes.
3) On souhaite écrire un programme qui demande à l’utilisateur un nombre
d’œufs et affiche le nombre de boîtes de 6 œufs nécessaires à leur
transport.
(indication : a//b donne le quotient de a par b dans la division
euclidienne.)
4) Ecrire un programme qui demande à l’utilisateur d’entrer un nombre de
secondes et qui affiche sous la forme d’heures/minutes/secondes.
(indication : a%b donne le reste de la division euclidienne de a par b)
Chapitre 2 LES STRUCTURES CONDITIONNELLES

L’instruction conditionnelle if permet de soumettre l’exécution d’une

instruction ou d’un bloc de code à une condition.

a=5
b=8
if a > 0 :
b += 1
print (a,b)
Une telle instruction est composée d’abord du mot clé if et d’une condition
puis du symbole « : » suivi d’une instruction ou d’un bloc de code en retrait.
Cette dernière instruction n’est exécutée que si la condition s’avère être vraie.
La seconde notion importante est celle de tabulations. Les tabulations sont
essentielles pour Python. Il ne s’agit pas , comme dans d’autres langages tels
que C++ OU LE Java , d’un confort de lecture mais bien d’un moyen pour
l’interpréteur où se trouve le début ou la fin d’un bloc.
Forme complète ( if,elif et else)
L’instruction else :
Le mot-clé else permet de définir une première forme de complément à notre
instruction if.
Age=21
if age >= 18 :
print (" vous êtes majeur. ")
else :
print (" vous êtes mineur. ")
Python exécute soit l’un soit l’autre et jamais les deux.
L’instruction elif :
Le mot clé elif est une contraction else if que l’on peut traduire très
littéralement par sinon si.
if a > 0 :
print (" a est positif. ")
elif a < 0 :
print (" a est négatif. ")
else :
print (" a est nul. ")
De nouveaux opérateurs
Les opérateurs de comparaison
Les conditions doivent nécessairement introduire de nouveaux opérateurs, dits
opérateurs de comparaison.

Opérateur Signification littérale

< Strictement inférieur à
> Strictement supérieur à
>= Supérieur ou égal à
<= Inférieur ou égal à
== Egal à
!= Différent de

Booléens
True et False sont les deux valeurs possibles d’un type que nous n’avons pas vu
jusqu’ici : le type booléen.
Age=21
majeur = False
if age >= 18 :
majeur = True
A la fin de cet exemple , majeur vaut True , si ;l’age est supérieur ou égal à 18.
Sinon il continue de valoir False.
Les mots-clés and, or et not
Pour tester si une variable se trouve dans un intervalle on peut écrire :
a=5
if a >= 2 :
if a <= 8 :
print (" a est dans l’intervalle. ")
else :
print (" a n’est pas dans l’intervalle. ")
else :
print (" a n’est pas dans l’intervalle. ")
Il existe cependant le mot clé and qui peut nous réduire les conditions
imbriquées :
if a >= 2 and a<= 8 :
print (" a est dans l’intervalle. ")
else :
print (" a n’est pas dans l’intervalle. ")
Sur le même mode , il existe le mot clé or :
if a < 2 or a > 8 :
print (" a n’est pas dans l’intervalle. ")
else :
print (" a est dans l’intervalle. ")
Enfin il existe le mot clé not qui inverse un prédicat. Le prédicat not a==5
équivaut donc à a !=5.
Exercices :
1) Faire un programme qui détermine si une année saisie par l’utilisateur
est bissextile.
2) Ecrire un programme qui demande trois entiers à l’utilisateur et affiche
ces trois entiers dans l’ordre croissant.
3) Ecrire un programme pour résoudre une équation du second degré.
4) a) Ecrire un programme qui demande à l’utilisateur de saisir deux lettres
et qui affiche la lettre majoritaire ( ou X si aucune n’est majoritaire)
b) Même question avec trois lettres.
Chapitre 3 LES BOUCLES
Les boucles constituent un moyen de répéter un certain nombre de fois des
instructions de votre programme.
La boucle for
L’instruction for travaille sur des séquences. Elle est en fait spécialisée dans le
parcours d’une séquence de plusieurs données , par exemple les chaînes de
caractères.
L’instruction for se construit ainsi :
for element in sequence :
exemple :
chaine= ’Bonjour’
for lettre in chaine :
print(lettre)
Ce qui nous donne le résultat suivant :
B
o
n
j
o
u
r
Fonction range()
La fonction range() renvoie une séquence de nombres , à partir de 0 (par
défaut) et incrémente de 1 ( par défaut) et s’arrête avant un nombre spécifié.
Range(start,stop,step)
Exemple :
r=range(4)
for i in r :
print(i)
Ce qui nous donne le résultat suivant :
0
1
2
3
Exercice :
1) Ecrire un programme qui demande un entier naturel n à l’utilisateur ,
puis calcule et affiche 1+2+3….+n , ainsi que l’entier n*(n+1)/2 .
2) La suite de Fibonacci est la suite Fn définie par F0=0 , F1=1 et pour tout
entier naturel n>1 Fn=Fn-1+Fn-2
Ecrire un programme qui demande à l’utilisateur un entier n>1 et qui
affiche la valeur de Fn .

La boucle while
Elle permet de répéter un bloc d’instructions tant qu’une condition est vraie.
La syntaxe de while est :
while condition :
exemple :
n=7
i=0
while i < 10 :
print ( i+1, ‘*’, n , ‘=’ , (i+1)*n)
i += 1
Ce qui donne le résultat suivant :
1*7=7
2*7=14
3*7=21
4*7=28
5*7=35
6*7=42
7*7=49
8*7=56
9*7=63
10*7=70
Les mots-clés break et continue
Le mot-clé break
Le mot-clé break permet tout simplement d’interrompre une boucle.
Exemple :
while 1 :
lettre=input(‘tapez Q pour quitter’)
if lettre == ‘Q’ :
print (‘fin de la boucle’)
break
La boucle while a pour condition 1, c'est-à-dire une condition qui sera toujours
vraie. On demande à l’utilisateur de taper une lettre , tant que l’utilisateur ne
saisit pas Q , le programme lui demande de taper une lettre. Quand il tape Q le
programme affiche fin de la boucle et la boucle s’arrête grâce au mot-clé break.
Le mot-clé continue
Le mot-clé continue permet de continuer une boucle, en repartant directement
à la ligne du while ou for.
Exemple :
i=1
while i < 20 :
if i % 3 == 0 :
i +=4
print ( ‘ on incrémente i de 4. i est maintenant égal à ‘, i)
continue
print ( ‘ la variable i= ‘, i)
i += 1
Ce qui donne le résultat suivant :
la variable i=1
la variable i=2
on incrémente i de 4. i est maintenant égal à 7
la variable i=7
la variable i=8
on incrémente i de 4. i est maintenant égal à 13
la variable i=13
la variable i=14
on incrémente i de 4. i est maintenant égal à 19
la variable i=19
Exercices :
1) La conjecture de Syracuse
En mathématiques, on appelle suite de
Syracuse une suite d'entiers naturels définie de la manière
suivante : on part d'un nombre entier strictement positif ; s’il est
pair, on le divise par 2 ; s’il est impair, on le multiplie par 3 et on
ajoute 1. En répétant l’opération, on obtient une suite d'entiers
strictement positifs dont chacun ne dépend que de son
prédécesseur.
Par exemple, à partir de 14, on construit la suite des nombres : 14,
7, 22, 11, 34, 17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2, 1, 4, 2…
C'est ce qu'on appelle la suite de Syracuse du nombre 14.
Ecrire un programme qui pour un entier naturel n entré par
l’utilisateur détermine et affiche le premier rang d’apparition de 1.
2) Codage et décodage affine
Pour transmettre un message secret, on utilise la procédure
suivante. A une lettre de l’alphabet , on associe le nombre lu dans
le tableau ci-dessous :
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

Le couple d’entiers (a,b) s’appelle la clé du codage. Soit x le

nombre obtenu à partir de la lettre de départ . On calcule y=a*x+b ,
ensuite le reste de la division de y par 26, enfin on associe à ce
reste la lettre correspondante par la lecture du tableau.
On choisit la clé (11,8).
a) Faire un programme qui code une lettre saisit par l’utilisateur.
b) Faire un programme qui code un mot saisit par l’utilisateur
c) Faire un programme qui décode une lettre saisit par l’utilisateur.
d) Faire un programme qui décode un mot saisit par l’utilisateur.
Chapitre 4 LES FONCTIONS

En programmation, on est souvent amené à utiliser plusieurs fois des

groupes d’instructions dans un but très précis. Les fonctions permettent
de regrouper plusieurs instructions dans un bloc qui sera appelé grâce à
un nom. D’ailleurs vous avez déjà vu des fonctions : print et input en font
partie par exemple. Vous devez bien vous rendre compte qu’il existe un
nombre incalculable de fonctions déjà construites en Python. Toutefois ,
vous vous apercevrez aussi que, très souvent un programmeur crée ses
propres fonctions.

La création de fonctions
On crée une fonction selon le schéma suivant :

def nom_de_la_fonction(parametre1,parametre2,….,parametreN) :
Bloc d’instructions
Exemple :
def table(nb) :
i=0
while i < 10 :
print(i+1,’*’,nb,’=’,(i+1)*nb)
i +=1

Vous pouvez passer en argument différents nombres, table(8) pour

afficher la table de multiplication par 8 par exemple.

On peut aussi envisager de passer en paramètre le nombre de valeurs à

afficher dans la table.
def table(nb,max) :
i=0
while i < max :
print(i+1,’*’,nb,’=’,(i+1)*nb)
i +=1
Si vous tapez à présent table(11,20), l’interpréteur vous affichera la table
de 11 de 1*11 à 20*11.

Valeurs par défaut des paramètres

On peut également préciser une valeur par défaut pour les paramètres
de la fonction. Vous pouvez par exemple indiquer que le nombre
maximum d’affichages doit être de 10 par défaut.
def table(nb, max=10) :
i=0
while i < max :
print(i+1,’*’,nb,’=’,(i+1)*nb)
i +=1
table(7)
Dans ce cas max vaudra 10 par défaut.
Si on veut changer à 20 par exemple la valeur du paramètre max on
appelle la fonction par table(7,max=20).

L’instruction return
Les fonctions travaillent en général sur des données et renvoient le
résultat obtenu, suite à un calcul par exemple.
Exemple :
def carre (valeur) :
return valeur*valeur
L’instruction return signifie qu’on va renvoyer la valeur, pour pouvoir la
récupérer ensuite et la stocker dans une variable par exemple. Cette
instruction arrête le déroulement de la fonction, le code situé après le
return ne s’exécutera pas.

variable = carre(5)

La variable variable contiendra , après exécution de cette instruction ,

25.

Les fonctions lambda

Python nous propose un autre moyen de créer des fonctions, des

fonctions courtes limitées à une seule instruction.

lambda arg1, arg2,….,argN : instruction de retour.

Exemple :
f=lambda x : x*x
y=f(5)
Vous pouvez tout simplement stocker votre fonction lambda dans une
variable par une simple affectation. La variable y contiendra 25.
 Exercices :

1) Définir une fonction valeur absolue qui prend un entier en argument

et renvoie sa valeur absolue.
2) a) Ecrire une fonction max2(a,b) qui renvoie le plus grand des deux
entiers a et b
b) En se servant de la fonction max2 écrire une fonction max3(a,b,c)
qui renvoie le plus grand des trois entiers a,b et c
3) Ecrire une fonction puissance (x,y) qui renvoie x à la puissance y.
4) a) Ecrire une fonction mult(a,b) qui renvoie le produit a*b
b) En se servant de la fonction mult(a,b) écrire une fonction fact(n)
qui renvoie la factorielle de n. ( n !=1*2*3*…..*(n-1)*n )
5) a) Ecrire une fonction bissextile(a) qui renvoie un booléen indiquant
si l’année a est une année bissextile.
b) Ecrire une fonction, nbjoursannee(a) qui renvoie le nombre de
jours de l’année a, enutilisant la fonction bissextile(a)
c) Ecrire une fonction nbjoursmois(a,m) qui renvoie le nombre de
jours du mois m de l’année a, en utilisant la fonction bissextile(a)
d) En utilisant la fonction nbjoursmois(a,m) , écrire un programme
qui demande une année à l’utilisateur et affiche le calendrier de cette année ,
c'est-à-dire la liste de tous les jours de tous les mois.
6) En utilisant les fonctions de l’exercice précédent , écrire une
fonction nbjours(jn,mn,an,j,m,n) qui renvoie le nombre de jours compris entre
deux dates données.
Chapitre 5 LES LISTES

Définition

En Python, les listes sont des objets qui peuvent en contenir d’autres. Ce
sont donc des séquences, comme les chaines de caractères, mais au lieu
de contenir des caractères, elles peuvent contenir n’importe quel objet.

Création de listes

La syntaxe :
ma_liste=[]

Quand vous affichez la liste, vous pouvez constater qu’elle est vide. Entre
les crochets, il n’y a rien. Toutefois, on peut également créer une liste
non vide, en lui indiquant directement à la création les objets qu’elle doit
contenir.

ma_liste = [1,2,3,4,5]
print(ma_liste)

Affiche [1,2,3,4,5]

La liste que nous venons de créer compte cinq objets de type int. Mais
rien de tout cela n’est obligatoire.
- Vous pouvez faire des listes de toute longueur
- Les listes peuvent contenir n’importe quel type d’objet.
ma_liste = [1,3.5,’une cheine’,[j]]
Nous avons créé ici une liste contenant quatre objets de types
différents : un entier, un flottant, une chaîne de caractères et une autre
liste.
Voyons à présent comment accéder aux éléments d’une liste :
ma_liste=[‘c’,’f’,’m’]
print(ma_liste[0]) # affiche ‘c’ le premier élément de la liste
ma_liste[1]=’Z’ # on remplace ‘f’ par ‘Z’
print(ma_liste) # affiche [‘c’,’Z’,’m’]
Comme vous pouvez le voir , on accède aux éléments d’une liste en
indiquant entre crochets l’indice de l’élément qui nous intéresse.
Insérer des objets dans une liste
Ajouter un élément à la fin de la liste se fait par append.
ma_liste=|1,2,3]
ma_liste.append(67) # On ajoute 67 à la fin de la liste.
print(ma_liste) # affiche [1,2,3,67]

Insérer un objet dans une liste à l’endroit voulu se fait par insert.
ma_liste=[‘a’,’b’,’d’,’e’]
ma_liste.insert (2,’c’) # On insère ‘c’ à l’indice 2.
print(ma_liste) # affiche [‘a’,’b’,’c’,’d’,’e’]

Concaténer des listes se fait par extend

ma_liste1= [1,2,3]
ma_liste2=[4,5,6]
ma_liste1.extend(ma_liste2) # On insère ma_liste2 à la fin de ma_liste1
print(ma_liste1) # affiche |1,2,3,4,5,6]

On peut concaténer aussi avec l’opérateur + ou +=

ma_liste1= [1,2,3]
ma_liste2=[4,5,6]
ma_liste1 += ma_liste2 # identique à extend
print(ma_liste1) # affiche |1,2,3,4,5,6]
Suppression d’éléments d’une liste
Le mot clé del
ma_liste=[1,2,3,4]
del ma_liste[0] # On supprime le premier élément de la liste
print(ma_liste) # affiche [2,3,4]
del ma_liste[2] # On supprime le troisième élément de la liste
print(ma_liste) # affiche [1,2,4]

La méthode remove
On peut aussi supprimer des éléments de la liste grâce à la méthode
remove qui prend en paramètre non pas l’indice de l’élément à
supprimer, mais l’élément lui-même.
ma_liste=[1,2,3,4]
ma_liste.remove(3) # On supprime l’élément 3
print(ma_liste) # affiche [1,2,4]

Le parcours de listes
ma_liste=[‘a’,’b’,’c’,’d’,’e’,’f’,’g’,’h’]
i=0
while i < len(ma_liste) : # len(ma_liste) envoie le nombre d’éléments
print(ma_liste[i])
i += 1

ou
ma_liste=[‘a’,’b’,’c’,’d’,’e’,’f’,’g’,’h’]
for elt in ma_liste :
print(elt)

La fonction enumerate

ma_liste=[‘a’,’b’,’c’,’d’,’e’,’f’,’g’,’h’]
for elt in enumerate(ma_liste) :
print(elt)
(0,’a’)
(1,’b’)
(2,’c’)
(3,’d’)
(4,’e’)
(5,’f’)
(6,’g’)
(7,’h’)

On pourrait aussi la boucle for avec deux variables :

ma_liste=[‘a’,’b’,’c’,’d’,’e’,’f’,’g’,’h’]
for i, elt in enumerate(ma_liste) :
print(‘A indice {} se trouve {}.’ . format(i,elt))
A indice 0 se trouve a.
A indice 1 se trouve b.
…
A indice 7 se trouve h.
Exercices :
1) Ecrire une fonction somme(tab) qui calcule et renvoie la somme des
éléments d’un tableau d’entiers. En déduire une fonction moyenne(tab)
qui calcule et renvoie la moyenne des éléments du tableau tab.
2) Ecrire une fonction produit(tab) qui calcule et renvoie le produit des
éléments d’un tableau d’entiers. Si le tableau contient 0, la fonction
devra envoyer 0 sans terminer le calcul.
3) Ecrire une fonction echnge(tab,i,j) qui échange dans le tableau tab les
éléments aux indices i et j.
4) En se servant de la fonction echange de l’exercice précédent écrire une
fonction miroir(tab) qui reçoit un tableau en argument et le modifie pour
échanger le premier élément avec le dernier, le second avec l’avant
dernier, etc.
5) Ecrire une fonction hamming(tab1,tab2) qui prend en paramètres deux
tableaux, que l’on supposera de la même taille , et qui renvoie le nombre
d’indices auxquels les deux tableaux différent.
6) Reprendre l’exercice précédent , sans supposer que les tableaux ont la
même taille.
7) Pour transmettre un message secret , on utilise cette procédure.
A une lettre de l’alphabet, on associe le nombre lu dans le tableau ci-
dessous :

A B C D E F G H I J K L M N O P Q R S T U V W X Y Z

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

Soit x le nombre obtenu à partir de la lettre de départ. On calcule y = ax + b

( Le couple d’entiers (a,b) s’appelle la clé du codage.)

On calcule ensuite le reste de la division de y par 26. Enfin on associe à ce reste

la lettre correspondante par lecture inverse du tableau.
 On choisit la clé (1,19)
Proposer un programme python qui décode YXKFTM

CHAPITRE6 Récursivité

On aborde dans ce chapître la programmation à l’aide de fonctions récursives.

Il s’agit d’une technique pour définir des concepts et résoudre certains
problèmes qu’il n’est parfois pas facile de traiter en programmant uniquement
avec des boucles.

Exemple : La somme des n premiers entiers 0+1+2+….+n

Une solution pour calculer cette somme consiste à utiliser une boucle for
comme dans le code suivant :

def somme (n) :

s=0

for i in range(n+1) :

s=s+i

return s

Il existe en effet une autre manière d’aborder ce problème comme le montre le

code suivant :

def somme (n) :

if n == 0 :

return 0

else :

return n + somme (n-1)

Application : Faire une fonction récursive qui retourne la puissance n-ième d’un
nombre x.
def puissance ( x,n) :

if n == 0 :

return 1

else :

return x*puissance ( x, n-1)

Cas récursifs multiples.

Il est également possible de définir une fonction avec plusieurs cas récursifs.
Par exemple , on peut donner une autre définition pour puissance ( x,n) en
distinguant deux cas récursifs selon la parité de n. En effet , si n est pair , on a
2 2
alors = . De même , si n est impair, on a alors = .

Ceci nous amène à définir la fonction puissance (x,n) de la manière suivante :

def puissance(x,n) :

if n==0 :

return 1

elif n==1 :

return x

else :

r=puissance(x,n//2)

if n%2==0 :

return r*r

else :

return x*r*r

Cette fonction récursive a en effet l’avantage de diminuer le nombre d’appels

récursifs.
Double récursion

Les expressions qui définissent une fonction peuvent aussi dépendre de

plusieurs appels à la fonction en cours de définition. Par exemple la fonction
fibonacci(n).

def fibonacci(n) :

if n==0 :

return 0

elif n==1 :

return 1

else :

return fibonacci(n-2)+fibonacci(n-1)

Exercices :

1) Donner une fonction récursive fact(n) qui renvoie n !=n*(n-1)*(n-2)*…*1

Par convention 0 !=1
2) Soit Un la suite d’entiers définie par
Un+1= Un/2 si Un est pair
= 3*Un +1 sinon.

Avec U0 un entier quelconque plus grand que 1.

Ecrire une fonction récursive syracurse(u) qui affiche les valeurs

successive de la suite tant que Un est plus grand que 1.

3) On considère la suite Un définie par la relation de récurrence suivante, où

a et b sont des réels quelconques :
Un = a si n=0
= b si n=1
=3*Un-1 + 2*Un-2 + 5 si n≥2

Ecrire une fonction récursive serie(n,a,b) qui renvoie n-ème terme de

cette suite pour des valeurs a et b données en paramètres.
4) Ecrire une fonction récursive boucle(i,k) qui affiche les entiers entre i et
k.
5) Ecrire une fonction récursive pgcd(a,b) qui renvoie le PGCD de deux
entiers a et b.
6) Ecrire une fonction récursive nombrechiffre(n) qui prend un entier positif
ou nul n en argument et renvoie son nombre de chiffre.
7) Ecrire une fonction récursive nombrebits1(n) qui prend un entier positif
ou nul en argument et renvoie le nombre de bits valant 1 dans la
représentation binaire de n.
8) Ecrire une fonction récursive appartient(v,t,i) prenant une valeur v , un
tableau t , et un entier i et renvoyant True si v apparait dans t entre
l’indice i (inclus) et len(t) (exclu) , et False sinon. On supposera que i est
toujours compris entre 0 et len(t).
9) Le triangle de Pascal est une présentation des coefficients binomiaux
sous la forme d’un triangle défini ainsi de manière récursive :
C(n,p) = 1 si p=0 ou n=p
=C(n-1,p-1) + C(n-1,p) sinon

Ecrire une fonction récursive C(n,p) qui renvoie la valeur de C(n,p), puis

dessiner le triangle de Pascal.

CHAPITRE 7 Utilisation avancée des tableaux

Itérer sur les éléments d’un tableau

Lorsque l’on veut répéter une opération pour chaque élément e d’un tableau t ,
il est possible d’utiliser l’instruction for directement sur le tableau lui-même, de
la manière suivante.

for e in t :

print(e)

Dans une telle forme, la boucle énumère les éléments du tableau : elle effectue
un tour pour chaque élément de t et l’élément inspecté à un tour donné est
associé à la variable e.

Exemple :

print (‘Directions possibles :’)

for d in [‘Nord’ , ‘Sud’ , ‘Est’ , ‘Ouest’] :

print(‘*’,d)

affiche les lignes suivantes.

Directions possibles :

*Nord

*Sud

*Est

*Ouest

Construire un tableau par compréhension

On veut construire un tableau de taille 100 contenant l’entier 3*i+1 dans sa

case d’indice i. Une solution possible est la suivante.
t=[0]*100

for i in range (100) :

t[i] = 3*i + 1

Python propose une syntaxe plus compacte encore pour combiner l’allocation
d’un tableau et son remplissage par une boucle.

[3*i+1 for i in range (100)]

Cette nouvelle construction mélange les crochets, qui explicitent que l’on
construit un tableau, et les mots-clés de la boucle for de Python, qui explicitent
que l’on remplit ce tableau avec une boucle. On appelle cela la notation par
compréhension.

Enfin on peut ne conserver que certaines valeurs prises par la variable , en

ajoutant une condition .

[i*i for i in range (30) if i%4==1]

[1,25,81,169,289,441,625,841]

Tableaux à plusieurs dimensions

Avec Python on peut construire un tableau dont les éléments sont eux-mêmes
des tableaux.

t=[[1,2,3,4],[4,5,6,7],[7,8,9,1]]

Pour accéder à un entier contenu dans ce tableau de tableaux , on commence à

accéder à l’un des trois tableaux puis on accède à l’un de ses éléments.

print ( t[2] [1])

affiche 8

ou encore en décomposant l’accès en deux temps avec une variable.

u=t[2]

print (u[1])

affiche 8
Un tel tableau de tableaux est appelé un tableau à plusieurs dimensions. Sur
l’exemple ci-dessus, il y a deux dimensions, la première ayant la taille 3 et la
seconde la taille 4. Pour un tel tableau , o, dira que sa taille est 3x4.

Construction

Pour construire un tableau de tableaux on peut se servir de la construction par

compréhension introduite dans la section précédente.
t= [[0]*4 for i in range(3)]
Parcours d’un tableau à plusieurs dimensions
Pour parcourir tous les éléments d’un tableau à plusieurs dimensions, on va
naturellement utiliser des boucles imbriquées, chaque boucle parcourant une
dimension. Si on prend notre tableau t de taille 3x4 et qu’on souhaite par
exemple faire la somme de tous ses éléments , on peut le faire avec deux
boucles imbriquées.
S=0
for i in range(3) :
for j in range(4) :
s+=t[i][j]
D’une façon équivalente on peut utiliser le parcours du tableau comme ci-
dessous.
S=0
for l in t :
for x in l :
s+=x

Tuples
Les tuples sont des listes immuables, qu’on ne peut modifier. Un tuple se
définit comme une liste, sauf qu’on utilise comme délimiteur des parenthèses
au lieu des crochets.
Tuple_vide=()
Tuple_non_vide=(1,2,3)
A la différence des listes les tuples une fois créés , ne peuvent être modifiée :
on ne peut plus y ajouter d’objet ou en retirer.
Exemple :
def decomposer (x,y) :
q=x//y
r=x%y
return q,r
retour= decomposer(20,3)
Vous allez capturer un tuple contenant deux éléments : le quotient et le reste
de la division de 20 par 3.
Exercices :
1) Construire un tableau de taille 100 répétant la séquence 0,1,2.
2) Ecrire un programme qui construit un tableau t de taille 11x11, tel que
t[i][j] contient i*j
3) Ecrire un programme qui créé un tableau à deux dimensions de taille
30x30 contenant des entiers tirés au hasard entre 1 et 9999, puis
l’affiche.
4) Compléter le programme précédent pour calculer et afficher l’élément
maximum de tableau.
5) Ecrire une fonction qui prend en paramètre un tableau à deux
dimensions et qui renvoie le maximum parmi les minima de chaque
ligne.
6) Ecrire une fonction dessin qui prend en paramètre un tableau de
dimension deux contenant des booléens, et qui le dessine à l’aide de
Turtle en représentant chaque occurrence de True par un carré noir.

Quelques instructions de turtle :

goto(x,y) : aller au point de coordonnées (x,y)
 forward(d) : avancer de la distance d
backward(d) : reculer de la distance d
left(a) : pivoter à gauche de l’angle a
right(a) : pivoter à droite de l’angle(a)
up() : relever le crayon et interrompre le dessin
down() : redescendre le crayon et reprendre le dessin
begin_fill() : activer le mode remplissage
end_fill() : désactiver le mode remplissage
from turtle import * : pour charger l’intégralité des instructions

Projet :
Le puissance 4 est un jeu à deux joueurs qui se joue sur une grille verticale de
six lignes et sept colonnes. A tour de rôle, chaque joueur fait tomber un pion de
sa couleur dans une colonne de son choix non encore pleine. Le premier joueur
qui aligne quatre pions de sa couleur, horizontalement, verticalement ou en
diagonale, gagne la partie. La partie est nulle si la grille est totalement remplie
sans qu’aucun joueur ne gagne.
Pour représenter une grille de ce jeu, on utilise un tableau à deux dimensions
de taille 6*7, la première dimension représentant les lignes et la seconde les
colonnes. Une ligne est notée l et prend une valeur entre0 et 5, la ligne 0 étant
située en bas ; une colonne est notée c et prend une valeur entre 0 et 6, la
colonne 0 étant à gauche. Un joueur est noté j et prend la valeur 1 ou 2. Dans
une grille , notée g, la valeur 0 représente une case vide et la valeur 1 ou 2
représente un pion du joueur correspondant.
1) Ecrire une fonction grille_vide() qui renvoie une grille vide.
2) Ecrire une fonction affiche(g) qui affiche une grille, avec le caractère.
pour une case vide, le caractère x pour le joueur 1 et le caractère o pour
le joueur 2. On prendra bien soin de bien afficher les lignes de haut en
bas.
3) Ecrire une fonction coup_possible(g,c) qui renvoie un booléen indiquant
s’il est possible de jouer dans la colonne c.
4) Ecrire une fonction jouer(g,j,c) qui joue un coup du joueur j dans la
colonne c en supposant que la colonne c n’est pas pleine.
5) Ecrire trois fonctions horiz(g,j,l,c), vert(g,j,l,c) et diag(g,j,l,c) qui
déterminent respectivement s’il y a un alignement de quatre pions du
joueur j à partir de la case (l,c)
6) Ecrire une fonction victoire(g,j) qui renvoie un booléen indiquant si le
joueur j a gagné.
7) Ecrire une fonction match_nul(g) qui renvoie le booléen indiquant s’il y a
un match nul.
8) Ecrire une fonction coup_aleatoire(g,j) qui joue un coup aléatoire pour le
joueur j, en supposant que la grille n’est pas pleine.
9) Ecrire un programme qui fait jouer deux adversaires aléatoirement à tour
de rôle, en affichant la grille après chaque coup, et qui s’arrête dès qu’un
joueur gagne ou que la partie est nulle.