Chapitre 1 : Les bases du Langage Python

UNIVERSITE CADI AYYAD

Faculté des Sciences Semlalia de Marrakech
Département de Mathématiques

Master SMA/Semestre 1/2023

Langage Python & Applications au Calcul Scientifique
M. L-Lahlou, FSSM
25/09/2023

**Il est vivement recommandé d'exécuter toutes les instructions du

cours**

1 Types de base
Les types les plus simples que l'on peut utiliser et manipuler sont :

• Les nombres numériques :

▪ int : entiers relatifs,
▪ float : nombres à virgule flottants,
▪ complex : nombres complexes représentés par un couple de float
• bool : Les booléens, deux valeurs True ou False

1.1 Opérations et expressions

Les opérateurs arithmétiques usuelles sont :

Opération Notation

+,- addition, soustraction

*,/,** multiplication, division,puissance

//,% quotient, reste de division euclidienne

In [ ]: 3*6 # Multiplication

In [ ]: 15/7 # Division décimale

In [ ]: 15//7 # Division euclidienne

In [ ]: 27%5 # reste de la division euclidienne

In [ ]: 8-2*5 # L'operateur * est prioritaire

In [ ]: (8-2)*5

In [ ]: 2**5 # exposant

1 of 21
 Expressions booleenes : sont formées par

Opération Notation

Comparaison de valeurs ==,!=,<,<=,>,>=

Logique and,or,not()

Identité is, is not

Appartenance in, not in

In [ ]: 1<=2

In [ ]: 5>3>-4 # equival a 5>3 and 3>-4

In [ ]: 0==-1

In [ ]: 3>1 or 12==5

In [ ]: not(1==-1)

1.2 Variables
Une variable est un identifiant d'un emplacement mémoire dans lequel on stocke une valeur.

• Toute variable est crée à partir du moment où elle est affectée par l'opérateur d'assignation = (à ne pas
confondre avec == ). Son type est automatique sans le besoin de le préciser : typage dynamique.
• Le nom de la variable est toujours à gauche de l'opérateur = .
• Le nom de la variable doit toujours commencer par une lettre majuscule ou minuscule et peut être combinaison de
lettre et de chiffres sauf les caractères spéciaux, comme *,&,#,espace, ...
Par exemple a3X est valide, mais 0a3# non valide

In [ ]: x=5 # initialisation et affectation d'une variable

print(x) # affiche le contenu de x
type(x) # type interne de x

In [ ]: x=1.5 # typage dynamique

type(x)

In [ ]: # le casting : changement de type

# forcé :
x=int(x) # modification de type
print(x)
type(x)

In [ ]: # le casting automatique
x=2 # int
y=1.5 # float
z=x+y # x --> float --> z est float
print(z)
type(z)

In [ ]: u=v=-5 # affectation simultanée

print(u)
print(v)

In [ ]: u,v,w=2,8,"bonjour" # affectations parallèles

In [ ]: print(u);print(v);print(w) # instructions séparées par ;

# noter que w contient une chaine.

In [ ]: t=1+U #erreur : sensible a la casse

In [ ]: z=4+6j # variable complexe

2 of 21
 In [ ]: print(z)

In [ ]: z.real # partie reelle

In [ ]: z.imag # partie imaginaire

In [ ]: z.conjugate() # fonction conjugate associee à l'objet z,

#appelee de cette façon renvoie le conjugue de z

In [ ]: (1+z**2)/(2-z.conjugate())

In [ ]: print(z,y)
z*y #operation sur complexes

In [ ]: print("z = ",z,"y = ",y)

Interaction avec l'utilisateur

print(objet) # affiche objet
print(objet1,objet2, ...)
# affiche les objets séparés par défault par des blancs

In [ ]: x,y,z=2,"python genial",'a'
print(x,y,z)

In [ ]: n=input("donner un nombre entier : ")

# affecte nombre saisi à n après le message

In [ ]: print(n)

In [ ]: # mais attention n est stocké en chaine

type(n)

In [ ]: n+3 # erreur

Attention! Le résultat de input() est toujours une chaine.

Si on veut saisir et stocker en nombre,
il faut convertir le résultat de la fonction input() à un type numérique à l'aide des fonctions int() ou float() .

In [ ]: n=int(n) # int() convertit au type integer.

type(n)

In [ ]: # ou bien directement :
n=int(input("donner un nombre entier : "))

In [ ]: type(n)

In [ ]: n-3

2 Objets itérables
Ce sont des objets regroupant plusieurs éléments :

• les chaines,
• les listes,
• les tuples,
• les ensembles,
• les dictionnaires.

2.1 Les chaines

3 of 21
 une chaine est délimitée par des "... " ou des '...'

In [ ]: a='Ali'
b="a un"
c="ordinateur"

print(a,b,c) # affichage de plusieurs variable séparées par des blancs

In [ ]: d=a+b+c
print(d) # cancatenation de chaînes

In [ ]: print(3*a) # dupliquer une chaine

In [ ]: a*b #opération non valide pour les chaines

In [ ]: a[0] # extraire les caractères par indexation

# en commençant toujours par 0

In [ ]: d[2:8]

In [ ]: len(d) # longueur d'une chaîne

In [ ]: ch="ma chaine"

In [ ]: ch[1]='yu' #attention une chaine est non modifiable

In [ ]: #caractères spéciaux : \n,\t, ... comme en langage C

st="algèbre\nanalyse"; print(st)
su="géométrie\tdifferentielle"; print(su)

2.2 Les listes

Une liste est un objet qui permet de stocker une collection de données hétérogènes (de n'importe quel type),
dynamiquement modifiables, embalés par des crochets : [elem1,elem2,...] .

In [ ]: x=[-1,3,0.5,'ok',-5,3]

In [ ]: print(x)

In [ ]: type(x)

In [ ]: x[0] # les listes sont indexees à partir de 0

In [ ]: x[3]

In [ ]: x[-1] #indice negatif positionne a partir de la fin de la liste

In [ ]: print(x[-2],x[-5])

In [ ]: x[2]=[0.5,"6"] #une liste est modifiable ou mutable

In [ ]: x[2]

In [ ]: print(x)

In [ ]: print(x[2][1])

In [ ]: [0.5,'6'] in x # test d'appartenance

• len(ls) : une fonction utile qui renvoie le nombre d'éléments d'une liste ls

In [ ]: len(x) # nombre d'elements de x

4 of 21
 In [ ]: x[2][1] #element d'indice 1 du 2eme element de x : récursivité

In [ ]: l=[] # ou l=list() : liste vide utile pour ceraines initialisations

print(l[0])

• range(...) : constructeur d'un objet appelé intervalle formé d'entiers selon une progression arithmétique. cet objet
est souvent employé dans l'instruction for (voir chapitre 2)

range(start,stop,step) # start,start+step,start+2step, start+3step, ...etc

# attention! l'extrémité stop n'est jamais incluse

• Pour récuperer la liste des éléments de range , on applique la fonction list( ) à l'objet range.

In [ ]: a=range(10) # 0,1,...,9 : start=0 par defaut, step=1 par default

print(a)
type(a)

In [ ]: list(a)

In [ ]: list(range(-4,4))

In [ ]: list(range(-4,4,2)) #avec pas=2

In [ ]: list(range(4,20,-3)) # pas négatif

Modification : ajouter, changer, insérer, enlever

In [ ]: x=[-6,5,4,'xy',-34]

In [ ]: print(x)

In [ ]: x.append(-9) #ajoute un élément à la fin de la liste

print(x)

In [ ]: x.insert(3,11) # inserer 11 avant l'indice 3

print(x)

In [ ]: x.remove('xy') #supprimer un élément

print(x)

In [ ]: del(x[5]) # autre méthode pour supprimer un élément

print(x)

In [ ]: l=[-3,4,6]
print(l+x) #cancaténation
print(l) # l non modifiée

In [ ]: l.append(x) # attention résultat différent que ci-dessus

print(l)

In [ ]: l=[-3,4,6]
l.extend(x) # etendre l à la fin
print(l)

Slicing : On peut accéder aux objets itérables comme les listes par tranches (slices en anglais)

In [ ]: ls=[4,6,3,'a',-1,3,12.5,'hello']
ls[1:6] # sous-liste d'éléments à partir de l'indice 1 à 5

In [ ]: ls[:6] # tous les indices jusqu'à l'indice indiqué non inclus

In [ ]: ls[5:] # tous les indices à partir de l'indice indiqué

5 of 21
 In [ ]: # Plus généralement :
# extraire une tranche d'une liste t : t[start:stop:step] (stop exclu)

t=list(range(4,70,2))
print(t)
t[5:30:4]

In [ ]: print(t) # t ne change pas

In [ ]: del(t[1:len(t):2]) #supprimer la tranche (ou t[1:len(t):2]=[])

In [ ]: print(t)

Copie de listes : l'opération assignation entre deux objets listes n'est pas une copie

In [ ]: i=-2
j=i # copie de variables simples
print('i = ',i,'et j = ',j)
j=2
print('i = ',i,'et j = ',j) # j modifiée, i inchangée

In [ ]: print('\nPour les listes : ')

t=list(range(5,40,2))
u=t
print('t = ',t)
print('u = ',u)
u[1]=-10 # on modifie u
print('u = ',u)
print('t = ',t) #toute modification de u affecte aussi t : reference au meme objet

In [ ]: # Pour une vraie copie : on utilise la méthode .copy()

t=list(range(5,40,2))
u=t.copy()
print('t = ',t)
print('u = ',u)
u[1]=-10 # on modifie u
print('u = ',u)
print('t = ',t) #toute modification de u affecte aussi t : reference au meme objet

Remarque : cette méthode ne marche qu'au premier niveau : si on a des listes imbriquées, il faut faire appel à la
fonction deepcopy du module copy (voir notion de modules et fonctions d'un module plus loin)

2.3 Tuples
_2/10/2023_
Collection ordonnée non modifiable d'éléments hétérogènes délimités par des virgules et emballés (non
nécessairement) par des parenthèses : (elem1,elem2,...) .
Ce type de données admet les mêmes méthodes que les listes à l'exception de celles de modification.

In [ ]: y = (2, 'x', -3.5) #ou y=2,'x',-3.5

print(y)
type(y)

In [ ]: y[0]=-1 # erreur, on ne peut modifier

In [ ]: a,b,c=y # décompacte le tuple y en 3 variables

print(a,b,c)
z=a,b,c # compacte 3 variables dans un tuple
print(z)

In [ ]: # fusionner des tuples

x=(2,-1,'z'); y=(1,3)
print(x+y)

In [ ]: # attention erreur
x+5
6 of 21
 In [ ]: #On peut former un tuple d'un seul élément comme suit :
t=(5,) # pour ne pas confondre avec une donnée de type simple
print(t)

x+t # fonctionne

Remarque.

• On peut transformer n'importe quelle liste en tuple par la fonction tuple( ) (et vice-versa par list( ))
• Les tuples sont moins flexibles que les listes à cause de l'immutabilité. Leur intérêt réside dans le fait qu'ils
occupent moins d'espace mémoire que les listes.

In [ ]: x=[1,"z",-5,2]
y=tuple(x)
print(y)
z=list((3,-5,"foo"))
print(z)

• enumerate() : la fonction enumerate(sequence,start) permet de construire à partir d'une sequence

(liste,tuple,chaine) un objet représentant sequence de couples (indice,valeur).

In [ ]: lst=list(range(-5,10,2))
print(lst)
en=enumerate(lst)
print(en)

'''
remarquer que en n'est pas en fait une liste
Pour le transformer en liste de couples (indice,valeur)
il faut appliquer le constructeur list()
'''
list(en) # start par defaut =0

In [ ]: en1=enumerate(lst,5); print(list(en1))# indexage commence par 5

2.4 Ensembles
Collection non ordonnée modifiable d'éléments hétérogènes uniques emboitée entre accolades {elem1,elem2,
... } .

Interêt : effectuer des opérations sur ces objets propres aux ensembles au sens mathématique (intersection, union, ...)

In [ ]: E1={'a','b'}
E1

In [ ]: E2={15,'b','c'}

In [ ]: E3=E1 & E2 # intersection

E3

In [ ]: E4=E1 | E2 # union
E4

In [ ]: s=set() # ensemble vide

s=s|{1,5} # on modifie s
s

In [ ]: s.add(6)
s

D'autres opérations peuvent être effectuées sur les ensembles (voir help('set') )

In [ ]: help('set')

7 of 21
 2.5 Dictionnaires
Les dictionnaires sont des objets pratiques lorsq'on veut manipuler des structures complexes que les listes ou les
tuples présentent des limites.
Un dictionnaire est une collection non ordonnés d'objets modifiables (comme les listes), mais indexés par clé au lieu
de la position. La forme des dictionnaires est :

{cle1:valeur1,cle2:valeur2,...}

Les clés doivent être uniques : deux éléments ne doivent pas partager la même clé.

In [ ]: #Exemple :
animal1={"nom":"girafe","taille":5.0,"poids":1100}
print(animal1)

On peut construire un dictionnaire d'une autre manière :

In [ ]: voiture={} #initialiser un dictionnaire vide

voiture['couleur']='noire'# remplissage par cle
voiture['poids']=4000
voiture['clim']='oui'

print(voiture)

Pour récuperer un élément d'un dictionnaire en mentionnant sa cle

In [ ]: print(animal1['poids'])

On peut rajouter ou supprimer des clés

In [ ]: voiture['hauteur']=1.70
print(voiture)
del voiture['clim']
print(voiture)

des méthodes qui renvoient respectivement les cles et les valeurs :

In [ ]: voiture.keys()

In [ ]: voiture.values()

Exercice 1.1

1. Construire la liste L formée des nombres xk = 2 + 8k tels que 2 ≤ xk ≤ 1002

2. Extraire de L la sous-liste sL constituée des nombres divisibles par 3.

Exercice 1.2

1. Construire un tuple T constitué des nombres n = −1, 0, 4, 8, 12, … , 100 et afficher T .

2. Afficher le nombre d' éléments de T sous la forme nombre elements du tuple est ... .
3. Lire au clavier un entier relatif quelconque z . En utilisant la seule variable T et en employant la méthode
insert des listes, trouver un moyen pour insérer dans T le nombre z de sorte que celui-ci soit l'avant
dernier élément. Afficher à nouveau T .

Exercice 1.3 Etant donné une liste L de nombres (éventuelement dupliqués), écrire des instructions utilisant les
ensembles et les listes pour obtenir le second nombre le plus élevé (on pourrait utiliser la méthode sort() des
listes. Par exemple si L=[10, 20, 54.36,2.5, 54.36, -45, 54.36, 25, 99, 99] , l'exécution donne :

le second nombre le plus haut est : 54.36

8 of 21
 Exercice 1.4

1. Définir le dictionnaire
d = {
'etudiant':'Rizki Ayoub',
'topologie': 11, 'algebre': 9.5,
'calcul differentiel': 9,
'integration':8,
'Info': 12} .
2. En utilisant uniquement la fonction list et la méthode values des dictionnaires, calculer la moyenne des
notes obtenues de la valeur de la cle 'etudiant' pour afficher le message :
la moyenne de Rizki Ayoub est : ...

5. Programmation
Les instructions de programmation est l'ensemble des commandes et expressions qui permettent de contrôler le flux
de l'exécution d'un algorithme. A partir du moment où la liste des instructions pour une tâche donnée s'allonge, le
mode interactif n'est pas adapté. nous allons utiliser un éditeur de texte, de préférence en environnement intégré
comme idle (sous Linux), ou spyder (sous anaconda,Linux ou Windows) pour rédiger ce qu'on appelle les scripts et
les modules (voir plus loin les définitions plus précises). Un fichier d'instructions est un fichier texte ASCII nommé
avec l'extenstion .py.

Chargez un environnement intégré :

• sous Linux idle à partir du menu Applications ou bien dans un Terminal système.
• sous Windows, anaconda puis spyder.
• familiarisez-vous avec l'environnement de votre choix.

Chaque environnement contient au moins un interpréteur python, un éditeur intélligent intégré et ses propres
fonctionnalités de développement.
L'environnement le plus léger que l'on va utiliser le plus souvent en salle est idle. Quelques démo sont présentées
pendant les séances de TP.

5.1 Instructions de contrôle

• Python comme d'autres langages permet d'automatiser des tâches plus compliqées à l'aide des instructions de
contrôle.

• Lesquelles sont formées par des blocs.

• Chaque bloc a un niveau de profondeur ou indentation.

Pour Python : dans un même bloc, deux instructions de même profondeur logique doivent avoir strictement la même
indentation.

9 of 21
 instruction_1
...
instruction_N
en-tete1: # bloc 1
instruction
...
instruction
en-tete2: # autre bloc dans bloc 1
ici
et ici
...
ici # retour au bloc 1
...
instruction # retour au niveau avant bloc 1

5.2 Instructions alternatives

les instructions alternatives sont gérées par les mots if, else, elif

if condition: # condition est une expression logique

bloc_instructions
#L'indentation obligatoire délimite les blocs d'instructions
ou
if condition:
bloc_instructions

else: # alignement obligatoire avec if

bloc_instructions

Pour former les conditions logique on utilise :

Opérateur Action

x==y égalité

x!=y non égalité

x<=y inférieur large

x<y inférieur strict

x>=y supérieur large

x>y supérieur stricte

x is y identité entre les identifiants x et y

x in y x appartient à y : chaine,liste,tuple,...

On peut former des expressions booléennes plus complexes à l'aide les opérateurs de logique : and,or,not

In [ ]: a = float(input("saisir un nombre : "))

b = float(input("saisir un autre nombre : "))

if a <b:
print('a plus petit que b ')

else:
print('a plus grand que b ')

10 of 21
 Plus généralement :

if condition1:
bloc_instructions
elif condition2:
bloc_instructions
.
.
.

elif conditionN:
bloc_instructions

else:
bloc_instructions

On a aussi une vesrsion plus compacte :

expression1 if condition else expression2

In [ ]: x=float(input("saisir un nombre : "))

print(1-x**2) if 0<x<1 else print(1+x**2)

5.3 Instructions itératives

• for : l'instruction for est adaptée pour parcourir n'importe quelle séquence (par ex. une liste ou une chaîne), dans
l'ordre où ils apparaissent dans la séquence.

for objet in sequence:

bloc_instructions

In [ ]: # Mesurer quelques chaines

a=["calcul","scientifique","en langage","python"]
for x in a:
print(x,"-->",len(x),"caracteres")

Construction fréquente : sequence est un intervalle range( ) :

In [ ]: for i in range(1,11):
print(i**2,end=' ') # remarquer l'option end de print

Autre utilisation puissante de for est la construction d'une liste à la volée :

In [ ]: '''
On veut construire une liste
contenant les cubes des entiers entre 1 et 30.
'''

# Première manière :
l1=[] # initialiser liste vide
for j in range(1,31):
l1.append(j**3)
print(l1)

In [ ]: # Seconde manière : à la volée plus compacte

l2=[i**3 for i in range(1,31)]
print(l2)

In [ ]: #Autre exemple : carrés des entiers pairs entre 1 et 50

print([i**2 for i in range(1,51) if i%2==0])

• while : L'instruction while est une itération plus générale. Elle exécute le bloc indenté tant que la condition de test
est réalisée.

11 of 21
 while condition:
bloc_instructions

In [ ]: a=10
while a>0.1:
print(a)
a=a/5

print(a) # derniere val de a apres boucle

Rupture de boucle :

• break : interrompre
• continue : court-circuiter

bloc_boucle
.
.
.
break #interruption de boucle
...
continue # passer au tour suivant

In [ ]: for x in range(1, 11):

if x == 5:
break # interruption
print(x)

In [ ]: for x in range(1, 11):

if x == 5:
continue # passer a l'itération suivante
print(x)

forme plus générale : les boucles for ou while peuvent posséder une clause else, c.a.d. ne s'exécute que si la boucle
se termine normalement (sans interruption)

In [ ]: sequence = [2, 5, 9, 7, 17]

cible = int(input("Entrez un entier :"))

for i in sequence:
if i == cible:
sauve = i
break # voici l’interruption

else: # en dehors boucle

print(cible, "n’est pas dans", sequence)
sauve = "Rien"

# sauve vaut donc cible ou Rien :

print("On obtient sauve =", sauve)

gestion exceptions : instruction try ... except

Opération effectuée à l’exécution par Python lorsqu’une erreur est détectée. C'est pour avoir du code plus robuste et
éviter l'arrêt non voulue de l'exécution.

In [ ]: for x in range(1,8):
y=(x**2-4)/(x-2)
print(y)
# produit erreur lorsque x=2 et l'exécution s'arrête

In [ ]: for x in range(1,8):
try:
y=(x**2-4)/(x-2)
print(y) # cas normal
except:
print(4) # gere l'exception en x=2

12 of 21
 Pour des informations plus complète sur la gestion des erreurs, consulter la doc à ce sujet.

9/10/2023

Exercice 1.5
(2n − 3)2
La suite (un )n ∈ N, n ≥ 1 définie par un = et k est un entier donné.
(n + 1)2

1. Pour un nombre k non nul saisi au clavier, afficher u0 , u1 , ⋯ , uk . Faire plusieurs essais :
k = 10, 20, 40, 100, 1000, 10⁴. Que peut-on dire ?

2. Ecrire quelques quelques instructions pour afficher le couple (n0 , un0 ), où n0 est le plus petit entier tel que pour
un nombre réel ϵ > 0 donné au clavier, on a 4 − un0 < ϵ. Tester pour ϵ = 10−3 , ϵ = 10−5 . Conclure.

Exercice 1.6
Soit la liste Ls=[-3,5,-6,14,-2,5,3,-11] . On veut réaliser ce qui suit :

• Pour un nombre k saisi au clavier,

• vérifier si la somme de 2 éléments distincts de la liste est k. L'algorithme doit afficher la liste de tous les couples
des éléments trouvés (en parcourant de gauche a droite, ou bien signaler que k est non trouvé. Ci-dessous des
exemples de l'éxeuction :

entrez votre nombre : 3

liste de couples trouvés, : [(5,-2),(14,-11),[(-2,5)]

entrez votre nombre : -7

aucun couple trouvé

idication : effectuer une double boucle sur ls et remplir au fur et a mesure une liste Lc de couples trouvés .

5.4 Les fonctions

Fonction : bloc d'instructions nommé, admettant des arguments (paramètres d'entrée) et qui s'exécute à la demande
(son appel).

• Elle peut avoir un ou plusieurs arguments ou aucun.

• Elle renvoie (ou retourne) éventuellement un ou plusieurs résultats au code appelant, appelés paramètres de
sortie.

def nomFonction(paramètres formels): # le mot cle def obligatoire

"""
Documentation de la fonction (docstrings)
"""

bloc instructions ou corps

Caractéristiques:

• Permet d'encapsuler des instructions afin de les réutiliser sans la nécessité de les réécrire.

• Partager des services et des données entre plusieurs programmes.

• Découpe une tâche en morceaux aux spécifications bien précises. Ce qui rend le code plus lisible et plus facile à
maintenir.

13 of 21
 In [ ]: #Exemple
def som(a,b):
s=a+b
return(s) # <-- retour de résultat

Définir et Appeler une fonction:

• le nom commence toujours par une lettre et peut contenir des chiffres
Attention! : il est interdit d'utiliser les caractères spéciaux : #,&,@,..

• Par convention de lisibilité, on commence le nom par une lettre miniscule et composer avec des majuscules et
(ou) des chiffres. Par ex. triBulle

• Le nom est sensible à la casse : Par ex. python reconnait print() et non Print() .

• On appelle la fonction dans un code appelant en mentionnant son nom exacte et en lui trasmettant les paramètres
effectifs dans le même ordre que la définition : nomFonction(paramètres effectifs) .

• La transmission des paramètres effectifs au moment de l'appel se fait par valeur (ou copie des valeurs effectives
vers les paramètres formels).

• Quand les paramètres occupent plus de place mémoire (liste,dictionnaire, ...), la transmission se fait par réference
: copie des adresses des paramètres effectifs dans les paramètres formels.

• Une fonction peut fournir un ou plusieurs résultats, ou même aucun.

▪ Si elle renvoie plusieurs résultats res1,res2,... , il est obligatoire d'utliser return(res1,res2,...)
▪ S'il n'ya aucun résultat l'instruction return n'est pas obligatoire.

In [ ]: som(4,6) # appel simple

In [ ]: x=som(4,6) # appel et assignation à une variable

print(x)

Remarque importante :

• Ne pas confondre print et return

• Tout code après le mot return est inutile ou code mort : l'interpréteur abandonne toute instruction quand il
rencontre ce mot.

In [ ]: def som2(a,b):
s=a+b
return(s)

In [ ]: x=som2(5,-7)
print(x) # None est une primitive interne qui n'a pas de type
x-1

Remarque importante: l'objet None renvoyé par le code précédent est une primitive interne qui n'a aucun type de
stockage. C'est souvent la source de plusieurs erreurs de traitements dans Python

In [ ]: def som3(a,b):
s=a+b
s1=a+2*b
s1=a+2*b
return(s1)

x=som3(5,-7)
print(x)
print(x-1)
14 of 21
 In [ ]: def somProd(a,b):
s=a+b
p=a*b
return(s,p) # retour de résultat multiple

#test
r,s=4,8
somProd(r,s) # copie de r,s dans a,b

In [ ]: # on peut affecter l'appel à une ou des variables

t,u=somProd(r,s)

print(t,u)

In [ ]: # ou bien
v=somProd(r,s) # ici v est automatiquement un tuple
print(v)
print(v[0])
print(v[1])

In [ ]: #ou encore une version plus compacte :

def somProd(x): # on va transmettre un tuple x
s,p=x[0]+x[1],x[0]*x[1]
return(s,p)

In [ ]: v=somProd((4,5))# <-- transmission d'un tuple

print(v)

Remarques :

• Les paramètres d'entrée peuvent être aussi des nom de fonctions.

• Une fonction peut appeler une autre.
• On peut même définir une fonction dans le bloc d'une autre.

In [ ]: #argument fonction
def f1(x):
return x+1

def g(func,t):
s=func(t**3)
return(s)

In [ ]: g(f1,-3)

paramètres obligatoires, ou optionnels:

Une fonction peut admettre des paramètres obligatoires (oupositionnels) à fournir au moment de l'appel et d'autres par
défaut (ou optionnels) : non nécessaires à l'appel.

In [ ]: def diff(a,b):
c=a-b
return(c)

In [ ]: diff(3) #erreur 2 paramètres positionnels obligatoires

In [ ]: diff(3,5)

Les paramètres optionnels sont spécifiés par mots clefs dans l'entête et doivent être placés après les paramètres
obligatoires dans la définition de la fonction.

In [ ]: def myfunc(m,n,r="science"):
# m,n obligatoires,r optionnel
return([m,n,r])

In [ ]: myfunc(5,4,4.5)

In [ ]: myfunc(5,4,3)
15 of 21
 In [ ]: myfunc([3,4,7],('3',[3,12]))

Si on veut appeler dans un ordre différent il faut expliciter le mot cle au moment de l'appel :

In [ ]: myfunc(s=-5,m=1,n='ici') # changement d'ordre en nommant explicitement

# au moment de l'appel

Nombre arbitraire de paramètres :

On peut définir et appler une fonction avec un nombre variable de paramètres effectifs comme dans l'exemple qui suit :

In [ ]: def somme(*args):
resu=0
for nombre in args:
resu=resu+nombre
return(resu)

print(somme(23))
print(somme(2,3,-8))
print(somme(1,-2,4,5,'e'))

Expression lambda : c'est une fonction anonyme (sans nom) formée par le mot clef lambda et d'instructions
simples en une seule ligne. C'est une construction utile dans certaines situations. La syntaxe est :

lambda parametres: instruction

In [ ]: #Exemple on veut calculer 1+x*y

a=(lambda n1, n2: 1+n1+n2)(2,-1) # arguments 2,-1

print("a= ",a)
b=(lambda n1, n2: 1+n1+n2)(3,6) # arguments 3,6
print("b= ",b)

In [ ]: #plus simple : on peut nommer une expression lambda

f=lambda n1, n2: 1+n1+n2
print(f(1,3))
print(f(-2,4))

In [ ]: # Autre exemple d'utilisation :

#on veut construire la liste des carrées des entiers n=1,⋯,10
l=[]
for i in range(1,11):
l.append(i**2)

print(l)

Une autre manière plus compacte sans structure de boucle est l'utilisation d'une fonction lambda avec la fonction
map(fonction,sequence) qui distribue une fonction sur une séquence :

In [ ]: #il est equivalent d'écrire :

ll=map(lambda x:x**2,range(1,11)) #objet map
ll=list(ll) # transformer l'objet map en liste
print(ll)

Portée des variables : il existe dans python des variables à portée globale et des variables à portée locale.

• Par exemple toute variable définie dans une fonction n’est accessible que par la fonction elle-même. On parle de
variable locale.

• Une variable définie à l'extérieur de la fonction est visible par la fonction, mais ne peut pas a la modifier. C'est une
variable globale.

• La modication d'une variable globale par une fonction s'effectue si on mentionne la directive global dans la
définition.
16 of 21
 In [ ]: def mask(a):
b=a+1 #b locale
a=a-1 #a modife localement
print("a = ",a,"b = ",b)

a=4
b=-3
mask(a)
print("a = ",a)
print("b = ",b)

Si on veut qu'une fonction modifie une variable définie en dehors de sa portée, il faut déclarer celle-ci dans la fonction
à l'aide du mot cle global

In [ ]: def maskbis(a):
global b #permet de modifier le b global
b=a+1

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

Récursivité : une fonction récursive est une fonction qui peut appeler elle même. Par exemple, considérons la suite
u1 = 4.0, un+1 = (un + 3)/2 qui converge vers 3. On peut la définir comme suit :

In [ ]: def f(n):
if n==1: return(4.)
y=(3+f(n-1))/2
return(y)

In [ ]: # les 15 premiers termes :

for k in range(1,16):
print(f(k))

Docstrings: les docstrings sont les commentaires qui expliquent la tâche de la fonction placés entre l'en-tête et le
début des instrunctions. Ces informations sont visibles au niveau de l'interpréteur par la commande help() .

In [ ]: def somDiff(x,y):
"""
fournit la somme et la difference
de 2 nombres arbitraires

Exemple : somDiff(1,2) retourne (3,-1)

"""
s=a+b
d=a-b

return(s,d)

In [ ]: help(somDiff)

17 of 21
 Exercice 1.7

1. Programmer de manière recursive une fonction facto (n) qui renvoie la valeur n!. On tient compte de la
convention 0! = 1 et on doit tester si on transmet un entier n ≥ 0. Dans le cas contraire, la fonction affiche le
message suivant :
erreur : votre nombre n'est pas valide! Donner un entier >=0 . Tester sur
n = −1, n = 0, n = 6.

On sait qu'une approximation de la fonction sin est :

x3 x5 x2k−1
sin(x) ≈ x − + + ⋯ + (−1)(k−1) , k≥1 (⋆)
3! 5! (2k − 1)!

2. Définir une fonction appsin(x,k) , d'arguments un nombre x et un entier optionnel par défaut k = 6 et qui
renvoie l'approximation (⋆).
3. Ecrire les instructions pour lire x, k au clavier et affiche l'approximation correspondante. Calculer en particulier
une approximation de sin(π/2), puis sin(π/6) (on pourrait prendre 3.1416 comme valeur approchée de π).
4. Reprogrammer une autre version de la fonction appsin2 qui nous fornit l'approximation (⋆) sans faire intervenir
la fonction facto . Retester pour les mêmes données que la question précédente et comparer.

6. Modules, Packages et Scripts

Dans cette section nous allons utiliser un éditeur de texte, de préférence en environnement intégré comme idle, ou
spyder pour rédiger les modules et les scripts (voir les démo pendant la séance des travaux pratiques).

6.1 Les modules

Un module Python est un fichier rassemblant des fonctions et classes relatives à un certain domaine. Par exemple le
module math fournit les fonctions et les constantes mathématiques usuelles (sqrt,pi,...) . On implémente un
module lorsque ces objets sont susceptibles d’être utilisés par plusieurs programmes. Dans une installation standard
de Python il y a déjà beucoup de modules disponibles sur différents thèmes. Mais il est très simple de créer un
nouveau. Il suffit d'écrire les fonctions, les constantes, ...etc dans un fichier et l'enregistrer sous un nom
nomModule.py .
Par exemple, écrivons le module messages.py suivant :

#Module inutile qui affiche des messages : -).

DATE = 16102021

def bonjour ( nom ):

#Dit Bonjour .
return(" Bonjour " + nom)

def logiciel ( nom ):

#Nom logiciel .
return(" votre Logiciel : " + nom)

def phone (num):

#No phone .
return(" votre No phone : " + num)

Pour accéder aux fonctions d’un module existant, il faut utiliser la commande import . Différentes manières pour
charger un module :

18 of 21
 • Méthode 1:
import nomModule # la plus recommandée
met les fonctions du module disponibles. Toute fonction ou objet fct dans module est alors accessibles via
nomModule.fct : fonction préfixée par le module. On peut même charger plusieurs modules en un seul import
: import nomModule1,nomModule2, ...

In [ ]: import messages

print(messages.DATE)
a=messages.bonjour("Khalid")
b=messages.phone("0665473812")
c=messages.logiciel("spyder")

print(a)
print(b)
print(c)

Docstrings : explications de ce que fait le module et comment utiliser chaque fonction. Ce sont des commentaires au
début du module et chaque fonction encadrés par des triples guillemets :

In [ ]: help(messages)

In [ ]: help(messages.logiciel)

Espace de noms, Portée des objets

le concept d'espace de nom (namespace) est le périmètre dans lequel un nom de variable, fonction, module, ... est
visible et utilsable.

• espace de noms global : contient tous les noms globaux visibles lorsqu'on charge l'interpréteur ou un programme
python.

• espaces de noms locaux : créés lors d'appels de fonctions (espace propre à chaque fonction ou module). Par
exemple les variables locales dans le corps dune fonction n’existent qu’au niveau de son espace de noms.
la fonction dir() permet de lister les objets de l'espace de noms courant. Si on met dir(objet) , on liste les
attributs de l'objet spécifié.

Exemple. : Pour connaitre les noms des objets définies dans le module on fait :

dir(nomModule)

In [ ]: sqrt(3 ) # erreur : sqrt n'est pas une fonction standard de python

In [ ]: import math # importe le module 'math'

dir(math) # noms visibles par math

In [ ]: math.sqrt(math.pi)
# Les fonctionnalités sont disponibles sous le suffixe 'math'

On peut importer en abrégant le nom du module par un alias :

In [ ]: import math as M # importe 'math' avec un alias 'M'

M.sqrt(M.pi)

• Méthode 2:
from nomModule import fct1,fct2, ...
on ne souhaite l’accès qu’aux objets z1, z2... spécifiées, lesquels sont accessibles directement sans les
préfixer par module.

19 of 21
 In [ ]: from math import sqrt, pi # importe uniquement 'sqrt','pi'

print(sqrt(pi))

In [ ]: '''
Attention : on ne fait pas ici dir(math),
mais dir() pour s'appercevoir que les noms sqrt,pi
sont visibles dans le namespace global :
on a utilisé ces noms sans préfixer par math
'''

dir() # On peut faire aussi %who ou %whos dans ipython

• Méthode 3:
from nomModule import * # non recommandée
accès direct à l’ensemble des objets du module indiqué sans devoir les préfixer par le nom du module. Par
exemple : from math import * : tous les noms contenus dans math sont disponibles sans préfixage.

Remarque. : cette méthode est déconseillée par les spécialistes à cause de risque de conflits entre les noms
identiques dans des des modules différents.

Consulter la documentation intégrée ou sur le web pour les quelques modules connus de la librairie standard suivants
:

Module domaine

os interface portable au système d’exploitation

glob, shutil expansion de noms de fichiers, copie et archivage de fichiers et arborescences

math, cmath interface aux outils de la librairie mathématique standard, opérations sur nombres complexes

pickle gestion d’objets persistants

string gestion des chaines de caractères

time interface aux fonctions temporelles du système

tkinter construction d’interfaces utilisateur graphiques (GUI) basé sur la librairie portable Tk

et beaucoup d’autres modules spécialisés

6.2 Les packages

Un package (paquetage, librairie ou bibliothèque) permet de réunir plusieurs modules sous un seul nom et pouvant
ainsi être chargés par une seule instruction import package. C’est donc un ensemble de modules physiquement
rassemblés dans un répertoire ou une arborescence. On peut charger un module, une fonction d’un certain module du
package en précisant son chemin. Par exemple :

import sound.effects.echo
Nous verrons dans les prochains chapitres les exemples des packages, modules et fonctions de
numpy,scipy,matplotlib.

20 of 21
 6.3 Les scripts
Un script est un fichier qui contient des instructions, des appels de fonctions, des imports de modules, de package . . .
etc. C’est en quelque sorte un programme principal destiné à être exécuté dans un interpreteur python. Ecrire le script
testMessages.py de test du module messages ci-dessus.

L'exécutions du script par les différentes façons :

• python testMessages.py en ligne de commande système (Terminal sous Linux)

• dans idle : menu −→ Run-Run Module (F5)
• dans ipython ou Jupyter : %run testMessages (extension non necessaire)

Exercice 1.8
Un entier x à n digits (x = a1 a2 ⋯ an ) est dit nombre d'Armstrong d'ordre n si x = an1 + an2 + ⋯ ann . Par exemple,

n
153 = 13 + 53 + 33 = 1 + 125 + 27 est un nombre d'Armstrong, mais 120 ne l'est pas car 13 + 23 + 03 = 9.
L’objectif de cet exercice est le développement d’un module Amstrong.py qui detecte et comptabilise les nombres
entiers d'Amstrong dans un sou-ensemble de N. Les tests seront effectués dans un script nommé
test_Amstrong.py .

1. Ecrire dans Amstrong.py une fonction lstChiffres(x) qui retourne la liste constituée des chiffres dans
lécriture de x supposé entier. Pour le réaliser, utiliser convenablement les fonction str et int . Tester sur
x=35823065 qui donne [3,5,8,2,3,0,6,5] .
2. Ecrire une fonction isArmstrong(x) qui retourne la constante logique True si x est un nombre
d'Amstrong, False sinon. Tester sur x=153 et x=1253 .
3. Ecrire une fonction listeArmstrong(K) qui construit et retourne la liste des nombres d'Armstrong qui sont
≤ K pour un entier K donné.
Tester pour K = 5000.

Exercice 1.9
On exige dans ce problème les imports de modules avec prefixage.
Python contient un module nommé random qui contient des fonctions de génération de nombres aléatoires.

1. Documentez vous sur random et sur la fonction randint .

2. i) Ecrire quelques instructions en mode interactif pour générer une liste de 50 entiers aléatoires entre 1 et 6. Cette
opération simule le lancé d’un dé à 6 faces 50 fois.
ii) Calculer simplement sans boucle le nombre de la face 3 dans la liste obtenue.
3. Ecrire un module nommé lanceDe.py où on définit deux fonctions :

• lance(N) une fonction qui renvoie une liste de longueur N qui simule le lancé N fois.
• simule(N,k) une fonction qui simule le lancé N fois pour obtenir la face k, c.a.d. la fonction renvoie le
nombre de fois de face k obtenue après la simulation.
Tester les fonctions dans un script testDe.py où on lit N, k au clavier et on affiche la simulation.

21 of 21