Programmation avec Python

Licence Sciences et Techniques GI

Pr. Lotfi ELAACHAK

Département Génie Informatique

2021 — 2022
 Table des matières

1 Les bases de Python 2

1.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.1.1 Pourquoi apprendre Python ? . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.1.2 Python First Program . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2 Variable et type de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.3 Instructions Python If-else . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.4 Instructions iteratives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.4.1 La boucle for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.4.2 La boucle while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.5 Fonction Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.5.1 Appel par référence en Python . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.5.2 La récursivité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.6 Tableaux Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.7 Les chaînes de caractères Python . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

2 Structure de données 11
2.1 Python List . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.2 Python Set . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.3 Python Tuple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.4 Python Dictionary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

3 Programmation fonctionnelle en Python 16

3.1 Concepts de la programmation fonctionnelle . . . . . . . . . . . . . . . . . . . . . 16
3.2 Fonctions pures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
3.3 Récursivité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
3.4 Les fonctions sont de première classe et peuvent être d’ordre supérieur . . . . . . . 18
3.4.1 Fonctions d’ordre supérieur intégrées . . . . . . . . . . . . . . . . . . . . . 18
3.5 Immutabilité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

1
 Chapitre 1
Les bases de Python
1.1 Introduction
Python est un langage de programmation généraliste, dynamique, de haut niveau et interprété.
Il prend en charge l’approche de programmation orientée objet pour développer des applications.
Il est simple et facile à apprendre et fournit de nombreuses structures de données de haut niveau.

Python est un langage de script facile à apprendre mais puissant et polyvalent, ce qui le rend
attrayant pour le développement d’applications.

La syntaxe et le typage dynamique de Python avec sa nature interprétée en font un langage idéal
pour les scripts et le développement rapide d’applications.

Python prend en charge plusieurs modèles de programmation, y compris les styles de program-
mation orientés objet, impératifs et fonctionnels ou procéduraux.

Python n’est pas destiné à fonctionner dans un domaine particulier, tel que la programmation
Web. C’est pourquoi il est connu sous le nom de langage de programmation polyvalent car il
peut être utilisé avec le Web, l’entreprise, la CAO 3D, etc.

Nous n’avons pas besoin d’utiliser des types de données pour déclarer la variable car elle est
typée dynamiquement afin que nous puissions écrire a=10 pour affecter une valeur entière dans
une variable entière.

Python accélère le développement et le débogage car aucune étape de compilation n’est incluse
dans le développement Python et le cycle édition-test-débogage est très rapide.

1.1.1 Pourquoi apprendre Python ?

Python fournit de nombreuses fonctionnalités utiles au programmeur. Ces caractéristiques en
font la langue la plus populaire et la plus largement utilisée. Nous avons énuméré ci-dessous
quelques fonctionnalités essentielles de Python.
— Facile à utiliser et à apprendre
— Langage expressif
— Langue interprétée
— Langage orienté objet
— Langage Open Source
— Extensible
— Large gamme de bibliothèques et de frameworks

2
1.1.2 Python First Program
Contrairement aux autres langages de programmation, Python offre la possibilité d’exécuter
le code en utilisant quelques lignes. Par exemple - Supposons que nous voulions imprimer le
programme "Hello World" en Java ; il faudra trois lignes pour l’imprimer.
Hello word
print("Hello word")

1.2 Variable et type de données

Python ne nous oblige pas à déclarer une variable avant de l’utiliser dans l’application. Il nous
permet de créer une variable au moment voulu.

Nous n’avons pas besoin de déclarer explicitement la variable en Python. Lorsque nous affectons
une valeur à la variable, cette variable est déclarée automatiquement.

L’opérateur égal (=) est utilisé pour affecter une valeur à une variable.

Variables et affectation
name = "Devansh"
age = 20
marks = 80.50

print(name)
print(age)
print(marks)

Les variables peuvent contenir des valeurs, et chaque valeur a un type de données. Python est
un langage à typage dynamique ; par conséquent, nous n’avons pas besoin de définir le type de
la variable lors de sa déclaration. L’interpréteur lie implicitement la valeur à son type.
Type de données
a=10
b="Hi Python"
c = 10.5
print(type(a))
print(type(b))
print(type(c))

Lotfi ELAACHAK Page 3

Types de données standard

1.3 Instructions Python If-else

Type de données
num = int(input("enter the number?"))
if num%2 == 0:
print("Number is even")
else :
print("Number is odd")

elif
number = int(input("Enter the number?"))
if number==10:
print("number is equals to 10")
elif number==50:
print("number is equal to 50");
elif number==100:
print("number is equal to 100");
else:
print("number is not equal to 10, 50 or 100");

Operateur logique
marks = int(input("Enter the marks? "))
if marks > 85 and marks <= 100:
print("Congrats ! you scored grade A ...")
elif marks > 60 and marks <= 85:
print("You scored grade B + ...")
elif marks > 40 and marks <= 60:

Lotfi ELAACHAK Page 4

 print("You scored grade B ...")
elif (marks > 30 and marks <= 40):
print("You scored grade C ...")
else:
print("Sorry you are fail ?")

1.4 Instructions iteratives

1.4.1 La boucle for

Boucle for
for i in range(10):
print(i,end = ' ')

n = int(input("Enter the number "))

for i in range(1,11):
c = n*i
print(n,"*",i,"=",c)

n = int(input("Enter the number "))

for i in range(2,n,2):
print(i)

1.4.2 La boucle while

Boucle while
i=1
While(i<=10):
print(i)
i=i+1

Boucle while et else

i=1
while(i<=5):
print(i)
i=i+1
if(i==3):
break
else:
print("The while loop exhausted")

Lotfi ELAACHAK Page 5

1.5 Fonction Python
Les fonctions sont l’aspect le plus important d’une application. Une fonction peut être définie
comme le bloc organisé de code réutilisable, qui peut être appelé chaque fois que nécessaire.

Python nous permet de diviser un grand programme en blocs de construction de base appe-
lés fonction. La fonction contient l’ensemble d’instructions de programmation entouré de . Une
fonction peut être appelée plusieurs fois pour permettre la réutilisation et la modularité du pro-
gramme Python.

Les fonctions Python présentent les avantages suivants :

— En utilisant des fonctions, nous pouvons éviter de réécrire la même logique/code encore
et encore dans un programme.
— Nous pouvons appeler des fonctions Python plusieurs fois dans un programme et n’importe
où dans un programme.
— Nous pouvons facilement suivre un grand programme Python lorsqu’il est divisé en plu-
sieurs fonctions.
— La réutilisabilité est la principale réalisation des fonctions Python.
Function
#function definition
def hello_world():
print("hello world")
# function calling
hello_world()

Function Avec param

#Python function to calculate the sum of two variables
#defining the function
def sum (a,b):
return a+b;

#taking values from the user

a = int(input("Enter a: "))
b = int(input("Enter b: "))

#printing the sum of a and b

print("Sum = ",sum(a,b))

1.5.1 Appel par référence en Python

En Python, appeler par référence signifie passer la valeur réelle comme argument dans la fonction.
Toutes les fonctions sont appelées par référence, c’est-à-dire que toutes les modifications apportées
à la référence à l’intérieur de la fonction reviennent à la valeur d’origine référencée par la référence.
Passage par reference

Lotfi ELAACHAK Page 6

#defining the function
def change_list(list1):
list1.append(20)
list1.append(30)
print("list inside function = ",list1)

#defining the list

list1 = [10,30,40,50]

#calling the function

change_list(list1)
print("list outside function = ",list1)

Passage d’un objet immutable

#defining the function
def change_string (str):
str = str + " Hows you "
print("printing the string inside function :",str)

string1 = "Hi I am there"

#calling the function

change_string(string1)

print("printing the string outside function :",string1)

1.5.2 La récursivité
La récursivité est le processus de définition de quelque chose en termes de lui-même.
En Python, nous savons qu’une fonction peut appeler d’autres fonctions. Il est même possible
que la fonction s’appelle elle-même. Ces types de construction sont appelés fonctions récursives.
L’image suivante montre le fonctionnement d’une fonction récursive appelée recurse.

Lotfi ELAACHAK Page 7

 Récursivité
def factorial(x):
if x == 1:
return 1
else:
return (x * factorial(x-1))

num = 3
print("The factorial of", num, "is", factorial(num))

1.6 Tableaux Python

Un tableau est défini comme une collection d’éléments stockés dans des emplacements de mémoire
contigus. C’est un conteneur qui peut contenir un nombre fixe d’articles, et ces articles doivent
être du même type. Un tableau est populaire dans la plupart des langages de programmation
comme C/C++, JavaScript, etc.

Le tableau est une idée de stockage de plusieurs éléments du même type ensemble et il est plus
facile de calculer la position de chaque élément en ajoutant simplement un décalage à la valeur
de base.

Le tableau peut être géré en Python par un module nommé array. C’est utile lorsque nous devons
manipuler uniquement des valeurs de données spécifiques. Voici les termes pour comprendre le
concept d’un tableau :
— Élément - Chaque élément stocké dans un tableau est appelé un élément.

Lotfi ELAACHAK Page 8

 — Index - L’emplacement d’un élément dans un tableau a un index numérique, qui est utilisé
pour identifier la position de l’élément.
Array
from array import *
arrayName = array(typecode, [initializers])

import array as arr

a = arr.array('i', [2, 4, 6, 8])
print("First element:", a[0])
print("Second element:", a[1])
print("Last element:", a[-1])

# changing first element

numbers[0] = 0
print(numbers) # Output: array('i', [0, 2, 3, 5, 7, 10])

# changing 3rd to 5th element

numbers[2:5] = arr.array('i', [4, 6, 8])
print(numbers) # Output: array('i', [0, 2, 4, 6, 8, 10])

del number[2] # removing third element

print(number) # Output: array('i', [1, 2, 3, 4])

a=arr.array('d',[1.1 , 2.1 ,3.1,2.6,7.8])

b=arr.array('d',[3.7,8.6])
c=arr.array('d')
c=a+b
print("Array c = ",c)

1.7 Les chaînes de caractères Python

La chaîne Python est la collection des caractères entourés de guillemets simples, doubles ou
triples. L’ordinateur ne comprend pas les caractères ; en interne, il stocke le caractère manipulé
comme la combinaison des 0 et des 1.

Chaque caractère est codé dans le caractère ASCII ou Unicode. On peut donc dire que les chaînes
Python sont aussi appelées collection de caractères Unicode.
String
#Using single quotes
str1 = 'Hello Python'
print(str1)
#Using double quotes
str2 = "Hello Python"

Lotfi ELAACHAK Page 9

print(str2)

str = "HELLO"
print(str[0])
print(str[1])
print(str[2])
print(str[3])
print(str[4])
# It returns the IndexError because 6th index doesn't exist
print(str[6])

# Given String
str = "JAVATPOINT"
# Start Oth index to end
print(str[0:])
# Starts 1th index to 4th index
print(str[1:5])
# Starts 2nd index to 3rd index
print(str[2:4])
# Starts 0th to 2nd index
print(str[:3])
#Starts 4th to 6th index
print(str[4:7])

str = "Hello"
str1 = " world"
print(str*3) # prints HelloHelloHello
print(str+str1)# prints Hello world
print(str[4]) # prints o
print(str[2:4]); # prints ll
print('w' in str) # prints false as w is not present in str
print('wo' not in str1) # prints false as wo is present in str1.
print(r'C://python37') # prints C://python37 as it is written
print("The string str : %s"%(str)) # prints The string str : Hello

Lotfi ELAACHAK Page 10

 Chapitre 2
Structure de données
L’organisation, la gestion et le stockage des données sont importants car cela permet un accès
plus facile et des modifications efficaces. Les structures de données vous permettent d’organiser
vos données de manière à vous permettre de stocker des collections de données, de les relier et
d’effectuer des opérations sur elles en conséquence.

Python prend implicitement en charge les structures de données qui vous permettent de stocker
et d’accéder aux données. Ces structures sont appelées List, Dictionary, Tuple et Set.

2.1 Python List

Les listes sont utilisées pour stocker des données de différents types de données de manière
séquentielle. Des adresses sont attribuées à chaque élément de la liste, appelée Index. La valeur
de l’index commence à 0 et se poursuit jusqu’au dernier élément appelé index positif. Il existe
également une indexation négative qui commence à partir de -1 vous permettant d’accéder aux
éléments du dernier au premier. Comprenons maintenant mieux les listes à l’aide d’un exemple
de programme.
List
my_list = [] #create empty list
print(my_list)
my_list = [1, 2, 3, 'example', 3.132] #creating list with data
print(my_list)

my_list = [1, 2, 3]
print(my_list)
my_list.append([555, 12]) #add as a single element

11
 print(my_list)
my_list.extend([234, 'more_example']) #add as different elements
print(my_list)
my_list.insert(1, 'insert_example') #add element i
print(my_list)

my_list = [1, 2, 3, 'example', 3.132, 10, 30]

del my_list[5] #delete element at index 5
print(my_list)
my_list.remove('example') #remove element with value
print(my_list)
a = my_list.pop(1) #pop element from list
print('Popped Element: ', a, ' List remaining: ', my_list)
my_list.clear() #empty the list
print(my_list)

my_list = [1, 2, 3, 'example', 3.132, 10, 30]

for element in my_list: #access elements one by one
print(element)
print(my_list) #access all elements
print(my_list[3]) #access index 3 element
print(my_list[0:2]) #access elements from 0 to 1 and exclude 2
print(my_list[::-1]) #access elements in reverse

my_list = [1, 2, 3, 10, 30, 10]

print(len(my_list)) #find length of list
print(my_list.index(10)) #find index of element that occurs first
print(my_list.count(10)) #find count of the element
print(sorted(my_list)) #print sorted list but not change original
my_list.sort(reverse=True) #sort original list
print(my_list)

2.2 Python Set

Les Sets sont une collection d’éléments non ordonnés qui sont uniques. Cela signifie que même si
les données sont répétées plus d’une fois, elles ne seront entrées dans l’ensemble qu’une seule fois.
Cela ressemble aux ensembles que vous avez appris en arithmétique. Les opérations sont égale-
ment les mêmes qu’avec les ensembles arithmétiques. Un exemple de programme vous aiderait à
mieux comprendre.
Set

Lotfi ELAACHAK Page 12

my_set = {1, 2, 3, 4, 5, 5, 5} #create set
print(my_set)

my_set = {1, 2, 3}
my_set.add(4) #add element to set
print(my_set)

my_set = {1, 2, 3, 4}
my_set_2 = {3, 4, 5, 6}
print(my_set.union(my_set_2), '----------', my_set | my_set_2)
print(my_set.intersection(my_set_2), '----------', my_set & my_set_2)
print(my_set.difference(my_set_2), '----------', my_set - my_set_2)
print(my_set.symmetric_difference(my_set_2), '----------', my_set ^ my_set_2)
my_set.clear()
print(my_set)

2.3 Python Tuple

Les tuples sont les mêmes que les listes, à l’exception du fait que les données une fois entrées
dans le tuple ne peuvent pas être modifiées quoi qu’il arrive. La seule exception est lorsque les
données à l’intérieur du tuple sont modifiables, alors seulement les données du tuple peuvent être
modifiées. L’exemple de programme vous aidera à mieux comprendre.
Tuple
my_tuple = (1, 2, 3) #create tuple
print(my_tuple)

my_tuple2 = (1, 2, 3, 'edureka') #access elements

for x in my_tuple2:
print(x)
print(my_tuple2)
print(my_tuple2[0])
print(my_tuple2[:])
print(my_tuple2[3][4])

my_tuple = (1, 2, 3)
my_tuple = my_tuple + (4, 5, 6) #add elements
print(my_tuple)

my_tuple = (1, 2, 3, ['hindi', 'python'])

my_tuple[3][0] = 'english'
print(my_tuple)
print(my_tuple.count(2))

Lotfi ELAACHAK Page 13

 print(my_tuple.index(['english', 'python']))

2.4 Python Dictionary

Les dictionnaires sont utilisés pour stocker les paires clé-valeur. Pour mieux comprendre, pensez à
un annuaire téléphonique où des centaines et des milliers de noms et leurs numéros correspondants
ont été ajoutés. Maintenant, les valeurs constantes ici sont le nom et les numéros de téléphone
qui sont appelés comme touches. Et les différents noms et numéros de téléphone sont les valeurs
qui ont été transmises aux touches. Si vous accédez aux valeurs des touches, vous obtiendrez
tous les noms et numéros de téléphone. C’est donc ce qu’est une paire clé-valeur. Et en Python,
cette structure est stockée à l’aide de dictionnaires. Laissez-nous comprendre cela mieux avec un
exemple de programme.
Dictionary
my_dict = {} #empty dictionary
print(my_dict)
my_dict = {1: 'Python', 2: 'Java'} #dictionary with elements
print(my_dict)

my_dict = {'First': 'Python', 'Second': 'Java'}

print(my_dict)
my_dict['Second'] = 'C++' #changing element
print(my_dict)
my_dict['Third'] = 'Ruby' #adding key-value pair
print(my_dict)

my_dict = {'First': 'Python', 'Second': 'Java', 'Third': 'Ruby'}

a = my_dict.pop('Third') #pop element
print('Value:', a)
print('Dictionary:', my_dict)
b = my_dict.popitem() #pop the key-value pair
print('Key, value pair:', b)
print('Dictionary', my_dict)
my_dict.clear() #empty dictionary
print('n', my_dict)

my_dict = {'First': 'Python', 'Second': 'Java'}

print(my_dict['First']) #access elements using keys
print(my_dict.get('Second'))

my_dict = {'First': 'Python', 'Second': 'Java', 'Third': 'Ruby'}

print(my_dict.keys()) #get keys
print(my_dict.values()) #get values
print(my_dict.items()) #get key-value pairs

Lotfi ELAACHAK Page 14

print(my_dict.get('First'))

Lotfi ELAACHAK Page 15

 3
Chapitre
Programmation fonctionnelle en Python
La programmation fonctionnelle est un paradigme de programmation dans lequel nous essayons
de tout lier dans le style des fonctions mathématiques pures. C’est un type déclaratif de style de
programmation. Son objectif principal est « que résoudre » par opposition à un style impératif
où l’objectif principal est « comment résoudre ». Il utilise des expressions au lieu d’instructions.
Une expression est évaluée pour produire une valeur alors qu’une instruction est exécutée pour
affecter des variables.

3.1 Concepts de la programmation fonctionnelle

Tout langage de programmation fonctionnel est censé suivre ces concepts.

— Fonctions pures : ces fonctions ont deux propriétés principales. Premièrement, ils pro-
duisent toujours la même sortie pour les mêmes arguments indépendamment de toute
autre chose. Deuxièmement, ils n’ont pas d’effets secondaires, c’est-à-dire qu’ils modifient
n’importe quel argument ou variable globale ou produisent quelque chose.

— Récursivité : Il n’y a pas de boucle « for » ou « while » dans les langages fonctionnels.
L’itération dans les langages fonctionnels est implémentée par récursivité.

— Les fonctions sont de première classe et peuvent être d’ordre supérieur : les fonctions de
première classe sont traitées comme des variables de première classe. Les variables de pre-
mière classe peuvent être transmises aux fonctions en tant que paramètre, peuvent être
renvoyées à partir de fonctions ou stockées dans des structures de données.

— Les variables sont immuables : En programmation fonctionnelle, nous ne pouvons pas

modifier une variable après son initialisation. Nous pouvons créer de nouvelles variables,
mais nous ne pouvons pas modifier les variables existantes.

3.2 Fonctions pures

Comme discuté ci-dessus, les fonctions pures ont deux propriétés.

— Il produit toujours la même sortie pour les mêmes arguments. Par exemple, 3+7 sera
toujours 10 quoi qu’il arrive.
— Il ne change pas ou ne modifie pas la variable d’entrée.

La deuxième propriété est également connue sous le nom d’immutabilité. Le seul résultat de la
fonction pure est la valeur qu’elle renvoie. Ils sont déterministes. Les programmes réalisés à l’aide
de la programmation fonctionnelle sont faciles à déboguer car les fonctions pures n’ont pas d’effets
secondaires ni d’E/S cachées. Les fonctions pures facilitent également l’écriture d’applications
parallèles/concurrentes. Lorsque le code est écrit dans ce style, un compilateur intelligent peut
faire beaucoup de choses - il peut paralléliser les instructions, attendre d’évaluer les résultats en
cas de besoin et mémoriser les résultats puisque les résultats ne changent jamais tant que l’entrée

16
ne change pas.
Pure function
def pure_func(List):

New_List = []

for i in List:
New_List.append(i**2)

return New_List

# Driver's code
Original_List = [1, 2, 3, 4]
Modified_List = pure_func(Original_List)

print("Original List:", Original_List)

print("Modified List:", Modified_List)

3.3 Récursivité
Au cours de la programmation fonctionnelle, il n’y a pas de concept de boucle for ou de boucle
while, à la place la récursivité est utilisée. La récursivité est un processus dans lequel une fonction
s’appelle directement ou indirectement. Dans le programme récursif, la solution du cas de base
est fournie et la solution du plus gros problème est exprimée en termes de petits problèmes. Une
question peut se poser quel est le cas de base ? Le cas de base peut être considéré comme une
condition qui indique au compilateur ou à l’interpréteur de quitter la fonction.
Récursivité
def Sum(L, i, n, count):

# Base case
if n <= i:
return count

count += L[i]

# Going into the recursion

count = Sum(L, i + 1, n, count)

return count

# Driver's code
L = [1, 2, 3, 4, 5]
count = 0
n = len(L)

Lotfi ELAACHAK Page 17

 print(Sum(L, 0, n, count))

3.4 Les fonctions sont de première classe et peuvent être

d’ordre supérieur
Les objets de première classe sont traités uniformément. Ils peuvent être stockés dans des struc-
tures de données, transmis en tant qu’arguments ou utilisés dans des structures de contrôle. On
dit qu’un langage de programmation prend en charge les fonctions de première classe s’il traite
les fonctions comme des objets de première classe.

Propriétés des fonctions de première classe :

— Une fonction est une instance du type Object.
— On peut stocker la fonction dans une variable.
— On peut passer la fonction en tant que paramètre à une autre fonction.
— On peut renvoyer la fonction à partir d’une fonction.
— On peut les stocker dans des structures de données telles que des tables de hachage, des
listes, . . .
Récursivité
# Python program to demonstrate
# higher order functions

def shout(text):
return text.upper()

def whisper(text):
return text.lower()

def greet(func):
# storing the function in a variable
greeting = func("Hi, I am created by a function passed as an argument.")
print(greeting)

greet(shout)
greet(whisper)

3.4.1 Fonctions d’ordre supérieur intégrées

Pour faciliter le traitement des objets itérables tels que les listes et les itérateurs, Python a im-
plémenté certaines fonctions d’ordre supérieur couramment utilisées. Ces fonctions renvoient un
itérateur peu encombrant. Certaines des fonctions intégrées d’ordre supérieur sont :

Map() : la fonction map() renvoie une liste des résultats après avoir appliqué la fonction donnée
à chaque élément d’un itérable donné (liste, tuple, etc.)

Lotfi ELAACHAK Page 18

 map
# Return double of n
def addition(n):
return n + n

# We double all numbers using map()

numbers = (1, 2, 3, 4)
results = map(addition, numbers)

# Does not Prints the value

print(results)

# For Printing value

for result in results:
print(result, end = " ")

filter() : La méthode filter() filtre la séquence donnée à l’aide d’une fonction qui teste chaque
élément de la séquence pour être vrai ou non.
filter
# function that filters vowels
def fun(variable):

letters = ['a', 'e', 'i', 'o', 'u']

if (variable in letters):
return True
else:
return False

# sequence
sequence = ['g', 'e', 'e', 'j', 'k', 's', 'p', 'r']

# using filter function

filtered = filter(fun, sequence)

print('The filtered letters are:')

for s in filtered:
print(s)

Fonctions lambda : en Python, fonction anonyme signifie qu’une fonction est sans nom. Comme

Lotfi ELAACHAK Page 19

nous le savons déjà, le mot-clé def est utilisé pour définir les fonctions normales et le mot-clé
lambda est utilisé pour créer des fonctions anonymes.

lambda arguments : expression

lambda
cube = lambda x: x * x*x
print(cube(7))

L = [1, 3, 2, 4, 5, 6]
is_even = [x for x in L if x % 2 == 0]

print(is_even)

3.5 Immutabilité
L’immuabilité dans un paradigme de programmation fonctionnelle peut être utilisée pour le
débogage car elle générera une erreur lorsque la variable est modifiée et non lorsque la valeur
est modifiée. Python prend également en charge certains types de données immuables tels que
string, tuple, numérique, etc.
Immutabilité
# String data types
immutable = "TestTest"

# changing the values will

# raise an error
immutable[1] = 'K'

Lotfi ELAACHAK Page 20

 Bibliographie
https ://openclassrooms.com/fr/courses/4302126-decouvrez-la-programmation-orientee-
objet-avec-python
https ://www.javatpoint.com/python-oops-concepts
https ://www.edureka.co/blog/data-structures-in-python/#linkedlist
https ://www.geeksforgeeks.org/functional-programming-in-python/

21