ATELIER 1 : MISE EN ŒUVRE DES

NOTIONS DE BASE DE PYTHON

Un rappel de cours avec syntaxe python:

1. TEST IF

L’instruction if peut comporter plusieurs tests conditionnels ’elif’ et se termine par un bloc
optionnel ‘else’. Le bloc qui sera exécuté, sera le premier ou la condition sera vrai sinon se sera
le bloc else sans condition qui sera exécuté.

Le if s’écrit de la forme suivante :

if <test1>:
<instructions>
elif <test2>:
<instructions>
.....
else:
<instructions>
Attention à l’indentation !!

2. BOUCLE WHILE

Comme dans beaucoup d’autres langages, la boucle while exécute un bloc tant que la condition
d’arrêt est vérifiée. La particularité de ce while est qu’il peut y avoir un else optionnel dont le
bloc sera exécuté lorsqu’on sort de la boucle

while <test> :
<instructions>

else :
<instructions>

UN EXEMPLE…

x=0
while x<6:
print ("Dans cette boucle x vaut : ", x)
x=x+1
else:
print ("Dans le else x vaut : ",x)
 3. BOUCLE FOR

La boucle for fonctionne sur les chaînes, les listes, les tuples et d’autres objets issus de classes.

Elle commence par une ligne d’en-tête qui spécifie une cible d’affectation, ainsi qu’un objet qui
sera itéré :

for <cible> in <objet>:

<instructions>
else :
<instructions>
Ici encore, le else est mis en fin de boucle pour la même raison que dans la boucle while vue
précédemment.

Le for de Python fonctionne différemment que celui du C, il affecte les objets de l’élément
séquence à la cible un par un.

EXEMPLE :

x={"ichi":"un","ni":"deux","san":"trois","chi":"quatre"}

print("Les clefs du dictionnaire sont : ",x.keys())

print("Les Valeurs du dictionnaire sont : ", x.values())

for i in x.keys():

print("La clef est : %s la valeur est :%s "%(i,x[i]))

4. RANGE

L’instruction range permet de créer une liste croissante d’entiers successifs compris dans une
certaine borne dépendant du nombre de paramètres de l’instruction :

1 paramètre : entiers compris entre 0 et le paramètre

2 paramètres : entier compris entre param1 et param2

3 paramètres : entier compris entre parm1 et param2 et de pas param3

EXEMPLE :

for i in range(10,20,2):
print(i)

APPLICATION 1 : JEU FIZZ BUZZ

Le jeu Fizz Buzz se passe comme suit:

 • Un joueur commence par dire le chiffre 1.
• Chaque joueur à tour de rôle prononce le numéro suivant, en comptant un à la fois.
• Si le nombre est divisible par 3, au lieu de dire le nombre, le joueur devrait dire "Fizz".
• Si le nombre est divisible par 5, au lieu de dire le nombre, le joueur devrait dire "Buzz".
• Si le nombre est divisible par 3 et 5, au lieu de dire le nombre, le joueur devrait dire "Fizz
Buzz".
• Si vous faites une erreur, vous êtes généralement éliminé du jeu et le jeu continu jusqu'à
ce qu'il ne reste plus qu'un seul joueur.

S'il n'y a pas d'erreur, les 15 premiers tours de Fizz Buzz devraient ressembler à ceci:

1
2
Fizz
4
Buzz
Fizz
7
8
Fizz
Buzz
11
Fizz
13
14
Fizz Buzz

Pour réaliser le jeu, complétez le code suivant :

for number in range(1, 101):

if …
…
else:
print(number)

PROGRAMME PYTHON POUR CALCULER LE SALAIRE BRUT

Le salaire brut est le montant d'argent qu'un employé gagne au cours d'une période donnée
avant toute déduction. Il existe de nombreuses façons de calculer le salaire brut en fonction de la
façon dont un employé est payé. Cet exemple décrit les deux méthodes les plus courantes:
horaire et salaire.

• Employé rémunéré à l'heure

Supposons que A travaille comme un employé rémunéré à l’heure et qu’il est payé 100/heure.

S'il a travaillé 50 heures par semaine, il recevra la rémunération des heures supplémentaires
pour les heures supplémentaires qu'il a travaillées, c'est-à-dire qu'il sera payé 1,5 fois 100 pour
10 heures (50-40).

Algorithme :
si working_hours> 40 alors:

salaire brut total = (salaire_horaire * 40) + (1,5 * salaire_horaire *

(heures_travaillées-40)).

si working_hours <40 alors:

salaire brut total = salaire_horaire * heures_travaillées.

ramu’s working_hours = 50, soit plus de 40 heures.

salaire brut total = 100 * 40 + (1,5) * 100 * 10 => 5,500.

• Employé salarié

Supposons que B travaille comme salarié et qu’il soit payé 12000 par an.

Si B a été payé mensuellement, le paiement brut sera de 12000 / 12.

• Question :

Proposez un programme qui calcule combien A sera payé. Le programme demande à l’utilisateur
d’enter le nombre d’heures.

LISTES

APPLICATION : OPERATIONS STATISTIQUES

Soit la liste suivante :

lst = [6, 6, 10, 15 , 9 , 8, 17, 5]

appliquez quelques opérations de bases telles que max, min, somme, count, sort (tri), len
(longueur) et moyenne sur cette liste.

Affichez les de la façon suivante :

Max : 17
Min :5
Somme : 76
Count : 1
Tri : [5, 6, 6, 8, 9, 10, 15, 17]
Longueur : 8
Moyenne : 9.5
 APPLICATION: LISTE DE SALAIRES

EXERCICE 1

Filtrez la liste de prix ci-dessous, pour ne garder que les prix entre 2000 et 3000.

prices = [500, 10, 5000, 2000, 3000, 4000, 2600, 2700]

Afin vous aidez on vous propose d’utiliser la fonction "append()" qui ajoute un élément dans la
liste. Pour cela vous créer une liste "filtered" vide et utiliser append pour la remplir.

filtered = []
for p in prices:
…

print(filtered)

EXERCICE 2

Pour cet exercice, votre programme doit effectuer les opérations suivantes:

employe = [
("Karim", 20000),
("Myriam", 9000),
("Ali", 4500),
("Safae", 379000),
("Ahmed", 365000),
("Amine", 356000),
("Rabha", 200000)
]
1. Calculez le salaire moyen de tous les employés.
2. Imprimez tous les employés dont le salaire est supérieur à la moyenne que vous avez
calculée.
3. Imprimez le nombre d’employés gagnant un salaire plus que la moyenne que vous avez
calculée.

DE LISTES AUX TABLEAUX

APPLICATION 1

x, y = 2.3, 15
z = 4*x + y/5
t = [1,1.5,2,2.5,3]
s = [0.1,0.2,0.3,0.4,0.5]
d = (t-s)**2 1.

• Dans les commandes ci-dessus quelles sont les variables créées ?

• Quel est le type affecté automatiquement à chacune des variables ?
Comme vous l’avez remarqué l’instruction de "d" génère une erreur. On ne peut pas faire
d’opérations mathématiques sur des listes globalement.

On peut le faire à l’aide d’une boucle sur les listes

t = [1,1.5,2,2.5,3]
s = [0.1,0.2,0.3,0.4,0.5]
d=list()
for i in range(len(t)):
d.append((t[i]-s[i])**2)
print(d)

ou il faut donc créer des vecteurs (numpy.array)

import numpy as np
t = np.array( [1,1.5,2,2.5,3])
s = np.array([0.1,0.2,0.3,0.4,0.5])
d = (t-s)**2

EXERCICE 1

Que donne le code suivant ?

import numpy
v = numpy.array([1, 2, 3, 4]) * numpy.pi / 4 # numpy.pi = π
w = numpy.sin(v)
print(w)

EXERCICE 2

De la même façon la fonction sin. Testez les fonctions de NumPy suivantes :

zeros([num]),
ones([num]),
linspace(debut, fin, num),
random.random([num])

Que font-elles ?

LES FONCTIONS

1. DÉFINITION

Outre les fonctions de bases de Python, il est possible d’en définir de nouvelles grâce à
l’instruction « def ». Il faudra bien sur à nouveau veiller à l’indentation car en python, il n’y pas
de délimiteur pour définir les scopes.
 format :

def nom_fct (arg1,arg2,…,argn):

<instruction>
return <valeur>
Lorsqu’on quitte la fonction valeur va directement être assignée à la fonction appelante.
Elle peut être de tous type puisque il n’y a pas de déclaration de type sous python.

2. LES ARGUMENTS…

La forme générale pour passer des arguments est nom_fct(arg1,arg2,…,argn)

Il est possible de définir des paramètres par défaut pour un ou plusieurs arguments. Ce qui
crée une fonction qui pourra être appelée avec moins d’arguments que ce qui a été défini.

Ex: def nom_fct (arg1=0, arg2=2,…,argn =« hello world »)

Les fonctions peuvent être appelées en utilisant des arguments mots-clés de la forme
« motclé=valeur »

Ex : def perroquet (voltage, etat='c\'est du solide',action='voom'):

print("-- Ce perroquet ne feras pas ", action,)

print("-- si vous le mettez sous ", voltage, " volts. ")

print ("-- Ca ", etat, " ! ")

pourrait être appelé de l’une des façons suivantes :

perroquet (1000)

perroquet (action = 'vooooooom', voltage = 1000000)

ARGUMENTS ARBITRAIRES

Une fonction peut être appelée avec un nombre d’arguments arbitraire. Il est possible de les
envoyer sous deux formes différentes :

Soit par dictionnaire :

Définition :

def intro(**data):

print("\nType de l\'argument:",type(data))

for key, value in data.items():

print("{} est {}".format(key,value))

Appel :

intro(Prenom="Sita", Nom="Sharma", Age=22, Phone=1234567890)

intro(Prenom="John", Nom="Wood", Email="johnwood@nomail.com",
Pays="Wakanda", Age=25, Phone=9876543210)

Soit par tuple :

Définition :

def adder(*num):
sum = 0

for n in num:
sum = sum + n

print("Sum:",sum)

Appel :

adder(3,5)
adder(4,5,6,7)
adder(1,2,3,5,6)

APPLICATION 1

Définissez quatre fonctions: additionner, soustraire, diviser et multiplier. Chaque fonction

doit prendre deux arguments et afficher le résultat de l'opération arithmétique indiquée par le
nom de la fonction.

Nous devons garder à l'esprit que la division par 0 va produire une exception.

Pour cela on va essayer de compléter le code suivant :

def additionner(a, b):

…

def soustraire(a, b):

…

def multiplier(a, b):

…

def diviser(a, b):

if b == 0:
…
 APPLICATION 2

Écrivez la fonction pay() qui prend comme entrée un salaire horaire et le nombre d'heures qu'un
employé a travaillé durant la semaine.

La fonction doit calculer et afficher le salaire de l’employé. Les heures supplémentaires

devraient être rémunérées de cette façon:

• toutes les heures au-delà de 40 mais inférieures ou égales à 60 devraient être

rémunérées à 1,5 fois le salaire horaire normal.
• Toutes les heures au-delà de 60 ans devraient être rémunérées à 2 fois le salaire horaire
normal.

pay(10, 35) 350 pay(10, 45) 475 pay(10, 61) 720

Pour résoudre cette exercice compléter le code suivant :

Sol :

def pay(salaire_h,nbr_h):
if nbr_h < 40:
…
…
…

pay(10,35)
pay(10,45)
pay(10,61)