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

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

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

In [ ]: (8-2)*5

In [ ]: 2**5 # exposant

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

2 of 24
 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

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
3 of 24
 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

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

4 of 24
 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])

5 of 24
 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

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)
6 of 24
 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é

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

7 of 24
 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)
8 of 24
 In [ ]: # attention erreur
x+5

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, ...)

9 of 24
 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')

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'])
10 of 24
 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

11 of 24
 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.

12 of 24
 • 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.

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

13 of 24
 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 ')

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)
14 of 24
 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.

while condition:
bloc_instructions

15 of 24
 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.

16 of 24
 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

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

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−8 . 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).
17 of 24
 • 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.

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() .

18 of 24
 • 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
print(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

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

x=som3(5,-7)
print(x)
print(x-1)

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)
20 of 24
 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)

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

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(r=-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,-1))

21 of 24
 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.

22 of 24
 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)

23 of 24
 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 π).

24 of 24