Ce document présente une introduction à la programmation en Python, y compris les différences entre compilation et interprétation, ainsi que les notions de base comme les variables, les commentaires et les entrées/sorties. Il explique également les différents types de Python, les opérateurs, les structures conditionnelles et les boucles, ainsi que les fonctions d'entrée et la manipulation de chaînes. Enfin, il aborde les opérateurs logiques et au niveau du bit, offrant un aperçu complet des fondamentaux du langage Python.

1. PROGRAMMATION STRUCTURÉ
Pointer@Info
Python

2. Chapitre I:
• mise en place de votre environnement de programmation;
• compilation vs interprétation;
• introduction à Python.
• Les Commentaire.
• Les variables
• Entée et sorties
• Les opérations

3. 1. Compilation vs interprétation - avantages et
inconvénients
Compilation vs Interprétation:
Compilation Interprétation
Avantages: • l'exécution du code traduit est
généralement plus rapide;
• le code traduit est stocké en langage
machine - comme il est très difficile de
le comprendre.
• vous pouvez exécuter le code dès que vous
l'avez terminé - il n'y a pas de phases
supplémentaires de traduction.
• le code est stocké en utilisant le langage de
programmation. pas celui de la machine
Désavantages: • la compilation elle-même peut être un
processus très long - vous ne pourrez
peut-être pas exécuter votre code
immédiatement après une
modification,
• ne vous attendez pas à ce que l'interprétation
accélère votre code à grande vitesse, votre
code partagera la puissance de l'ordinateur
avec l'interpréteur, il ne peut donc pas être
très rapide;

4. 2. introduction à Python
Qu'est-ce que tout cela signifie pour vous?
• Python est un langage interprété.
• Python, utilise son l'interpréteur Python pour exécuter le code.
• les langages interprété sont souvent appelés langages de script, tandis que le
code sont appelés scripts.
• Python est un langage de programmation largement utilisé, interprété, orienté
objet et de haut niveau avec une sémantique dynamique, utilisé pour la
programmation à usage général.
• le nom du langage de programmation Python vient d'une ancienne série de
croquis de comédie télévisée de la BBC appelée Monty Python's Flying Circus.
Qu'est-ce que Python?

5. 2. introduction à Python
Qui a créé Python?
• Python été créer par une seule personne. Guido van Rossum, né en 1956 à
Haarlem, aux Pays-Bas.
• Bien sûr, Guido van Rossum n'a pas développé et fait évoluer lui-même tous les
composants Python.
• C’est un open source, afin que chacun puisse contribuer à son développement.
Les rivaux de Python :
• Perl - un langage de script créé à l'origine par LarryWall;
• Ruby - un langage de script à l'origine écrit parYukihiro Matsumoto.

6. 2. introduction à Python
Où pouvons-nous voir Python en action?
Internet services Comme moteurs de recherche, le stockage et les
outils dans le cloud, les médias sociaux, etc.
Pourquoi pas Python?
• programmation de bas niveau
• applications pour appareils mobiles:
Il y a plus d'un Python
• Il existe deux principaux types de Python, Python 2 et Python 3.
• Python 3 est la version la plus récente. Notre version dans ce module
• ce cours se concentrera sur CPython.

7. 2. introduction à Python
LesTypes de python:
Python aka Cpython:
• PSF (Python Software Foundation), une communauté qui vise à
développer, améliorer, étendre et vulgariser Python et son
environnement.
• Le président du PSF est Guido von Rossum lui-même, et pour cette
raison, ces Pythons sont appelés canoniques. Car c’est un référence
pour toute autre implémentation du langage python.
• Tous les Pythons provenant du PSF sont écrits en langage "C". (La
premiére version de python en C). C'est pourquoi l'implémentation PSF
est souvent appelée CPython.

8. 2. introduction à Python
LesTypes de python:
Cython:
• Un autre membre de la famille Python est Cython. le manque d'efficacité.
• Cython est destiné à faire - traduire automatiquement le code Python en
code "C".
Jython:
• Une autre version de Python s'appelle Jython.
• "J" est pour "Java".
PyPy and RPython:
un Python dans un Python. En d'autres termes, il représente un
environnement Python écrit en langage de type Python nommé RPython
(Restricted Python).

9. 3. Utilisation de Python 3
• télécharger une copie sur : https://www.python.org/downloads/.
• un éditeur qui vous assistera dans l'écriture du code.
• une console dans laquelle vous pouvez lancer ou arrêter votre
compilation;
• un outil nommé débogueur, capable de lancer votre code pas à pas
et vous permettant de l'inspecter à chaque instant de l'exécution.
• Autre outils : IDLE est un acronyme: Integrated Development and
Learning Environment.

10. 3. Premier programme en Python
• Créer un fichier python et sauvegarder avec l’extension : .py
• Comment écrire et exécuter votre tout premier programme
print(" hello Python !!")
print(" hello ", "Python " , " Programmer !!")

11. 4. Commentaire en Python
• Une remarque insérée dans le programme, qui est omise lors de l'exécution, est
appelée un commentaire.
• En Python, un commentaire est un morceau de texte qui commence par un signe
# (dièse) et se prolonge jusqu'à la fin de la ligne.
# Ce programme évalue l'hypoténuse c.
# a et b sont les longueurs des jambes.
a = 3,0
b = 4,0
c = (a ** 2 + b ** 2) ** 0.5 # Nous utilisons ** au lieu de la racine carrée.
print ("c =", c)

12. 5. Les variables
• Python propose des «boîtes» (conteneurs) appelées
variables - dont le contenu de ces conteneurs peut
être modifié de n'importe quelle façon.
• variable Python a:
 un nom;
 une valeur (le contenu du conteneur)
• Le Nom d’une variable :
 composé de lettres majuscules ou minuscules
 chiffres et le caractère _
 le nom de la variable ne doit être aucun des
 mots réservés de Python (les mots-clés)
['False', 'None', 'True', 'and',
'as', 'assert', 'break', 'class',
'continue', 'def', 'del', 'elif',
'else', 'except', 'finally', 'for',
'from', 'global', 'if', 'import', 'in',
'is', 'lambda', 'nonlocal', 'not',
'or', 'pass', 'raise', 'return', 'try',
'while', 'with', 'yield’]
Mots Clés python à éviter

13. 6. Les variables
Création d’unVariable :
• Python est un language dynamiquement typé, c’est t’a dire nous avon pas besoin de faire la
declaration des variables.
• Chaque variable doit avoir une nom unique – l’identifieur
• utilisez simplement le nom de la variable désirée, puis le signe égal (=) et la valeur que vous
voulez mettre dans la variable.
Exemples:
Car = ‘a’ ou car =“a” => Un caractére
client_name = "John Doe“ => Une chaine de carachéte
var = 11 => Un entier
Var =True => Une valeur Boolean
account_balance = 1000.0 => Un réel
var = var + 1
var = 200 + 300
Nom_Vriable = Valeur_Variable

14. 7. Fonction de lecture : input()
La fonction input():
• Permet de lire et traiter les données.
• Entré la valeur par clavier et valider par enter.
• le résultat de la fonction input () est une chaîne.
Fonction input sans Argument :
Fonction input avec Argument/ Paramètre : c'est une chaîne contenant un
message
Nom_Vriable = input()
Nom_Vriable = input(“Entrer Votre Variable:")

15. 7. Fonction de lecture : input()
Exemple :
La dernière ligne de la phrase explique tout - vous avez essayé d'appliquer l'opérateur
** à 'str' (chaîne) accompagné de 'float'.

16. 7. Fonction de lecture : input()
Le transtypage
Python propose deux fonctions simples pour spécifier un type de données et résoudre ce
problème - les voici:
• int ()
• float ()
Exemple:
• leg_a = float(input("Input first leg length: "))
• leg_b = float(input("Input second leg length: "))
• print("Hypotenuse length is", (leg_a**2 + leg_b**2) ** .5)
Input first leg length: 6
Input second leg length: 9
Hypotenuse length is 10.816653826391969

17. 8. Opérateurs de chaîne
La Concaténation:
Le signe + (plus), lorsqu'il est appliqué à deux chaînes, devient un opérateur de
concaténation: chaîne + chaîne Il concatène (colle) simplement deux chaînes en une
seule.
Exemple :
• fnam = input("May I have your first name, please? ")
• lnam = input("May I have your last name, please? ")
• print("Thank you.")
• print("nYour name is " + fnam + " " + lnam + ".")
May I have your first name, please? Shar
May I have your last name, please? Janati
Thank you.Your name is Shar Janati.

18. 8. Opérateurs de chaîne
Réplication
Le signe * (astérisque), lorsqu'il est appliqué à une chaîne et un nombre (ou un nombre et
une chaîne, car il reste commutatif dans cette position) devient un opérateur de
réplication:
• string * number ou bien
• number * string
Il réplique la chaîne le même nombre de fois spécifié par le nombre.
Example :
• "James" * 3 donne: "JamesJamesJames"
• 3 * "an" donne: "ananan"
• 5 * "2" (or "2" * 5) donne: "22222" (not 10!)
Un nombre inférieur ou égal à zéro produit une chaîne vide.

19. 8. Opérateurs de chaîne
Conversion de type: str ()
• convertir un nombre en une chaîne.
• Une fonction capable de faire cela s'appelle str (): str (number)
Exemple:
leg_a = float(input("Input first leg length: "))
leg_b = float(input("Input second leg length: "))
print("Hypotenuse length is " + str((leg_a**2 + leg_b**2) ** .5))

20. 9. Les Opérateurs
Une expression est une combinaison des valeurs, des operateurs, des fonctions qui
donne une valeur comme resultat.
• Exemple : 1+2*8
Les opérateurs Arithmétique dans Python :
• Addition +
• Subtraction –
• Multiplication *
• Division Classique / (retourne un float si une seul valeurs est de type float)
• Modulo %
• Exponentielle ** (left operand raised to the power of right operand/
The exponentiation operator uses right-sided binding, e.g., 2 ** 2 ** 3 = 256.
• Division entier // rapprochement a la valeur petit

21. 9. Les Opérateurs
List des Opérateurs:
Remarque: nous avons énuméré les opérateurs dans
l'ordre de la priorité la plus élevée (1) à la priorité la
plus basse (4).
• utiliser des parenthèses, ce
qui peut changer l'ordre
naturel d'un calcul
• Conformément aux règles
arithmétiques, les sous-
expressions entre
parenthèses sont toujours
calculées en premier.

22. Chapitre II:
• Valeurs booléennes;
• Instructions conditionnelles et leurs exercices (if-elif-else) ;
• Les boucles while et for ;
• Les fonction Range, Break, Continue
• Contrôle de flux ;
• Opérations logiques et au niveau du bit ;

23. 1. Valeurs booléennes
Comparaison: opérateur d'égalité :
•Vous utilisez l'opérateur == (égal égal ).
•== est la question de savoir si ces valeurs sont égales ; a == b
compare a et b.
•Inégalité: l'opérateur pas égal à (! =)
•Autre Opérateurs de comparaison: >, >=, <, <=

24. 1. Valeurs booléennes
Exemple :
•Opérateurs de comparaison: supérieur ou égal :
centigrade_outside>= 0.0 # supérieur ou égal à
•Opérateurs de comparaison: inférieurs ou égaux :
current_velocity_mph < 85 # moins que
current_velocity_mph <= 85 # inférieur ou égal à

25. 1. Valeurs booléennes
Utilisation dans des réponses : Résultat utilisé pour prendre des
décision:
answer = number_of_lions >= number_of_lionesses
Answer = True
Ou bien
Answer = False

26. 1. Valeurs booléennes
Mise à jour le tableau des priorités:

27. 2. Instructions conditionnelles et leurs exercices
(if-elif-else) ;
Conditions et exécution conditionnelle
•Si une condition est remplie, en applique une instruction
conditionnelle.
•une seule déclaration if :
l'indentation :
• Utiliser quatre espaces d'indentation.
• Utiliser le caractère de tabulation;

28. 2. Instructions conditionnelles et leurs exercices
(if-elif-else) ;
•Une déclaration if – else :
Nous savons maintenant ce que nous ferons si les conditions sont
remplies, et nous savons ce que nous ferons si tout ne se passe pas
comme prévu. En d'autres termes, nous avons un «plan B».

29. 2. Instructions conditionnelles et leurs exercices
(if-elif-else) ;
Une déclaration if – else :
Tout ce que nous avons dit sur l'indentation
fonctionne de la même manière dans la
branche else

30. 2. Instructions conditionnelles et leurs exercices
(if-elif-else) ;
Instructions if-else imbriquées :
Tout d'abord, considérons
le cas où l'instruction
placée après le
if est un autre if.

31. 2. Instructions conditionnelles et leurs exercices
(if-elif-else) ;
La déclaration elif :
elif est utilisé pour vérifier plus d'une
seule condition et pour s'arrêter lorsque
la première instruction vraie est trouvée.

32. 2. Instructions conditionnelles et leurs exercices
(if-elif-else) ;
EXO1
• Écrire un programme qui permet d’afficher le résultat d'un étudiant à un module sachant que ce
module est sanctionné par une note d'oral de coefficient 1 et une note d'écrit de coefficient 2. La
moyenne obtenue doit être supérieure ou égale à 10 pour valider le module.
EXO2
• Lire 2 nombres A et B et afficher l’un des 3 messages suivants : « A égale à B » , « A supérieur à B
», « A inférieur à B ».
EXO3
• Lire deux nombres(A et B) , choisir l’opération ( + , -, * , /) à effectuer puis affiche le résultat.

33. 3. Boucler avec while
Syntaxe while :
 Lorsque la condition est remplie, while répète l'exécution tant que la condition
prend la valeur True.
 Remarque: toutes les règles d'indentation sont également applicables ici.
Exemple while :
Une boucle infinie, également appelée boucle sans fin, est une séquence
d'instructions dans un programme qui se répète indéfiniment (boucle sans fin).

34. 3. Boucler avec For
 Un autre type de boucle disponible en Python vient du constat qu'il est parfois
plus important de compter les "tours" de la boucle.
 For permet de «parcourir» de grandes collections de données élément par
élément.
Syntaxe For :
Exemple For :
Exemple For sur chaine :

35. 3. Boucler avec For
 La fonction range() génère une séquence de nombres. Il accepte des entiers et
renvoie des objets de plage.
La syntaxe de range() :
 Start est un paramètre facultatif spécifiant le numéro de départ de la
séquence ( 0 par défaut).
 Stop est un paramètre obligatoire spécifiant la fin de la séquence générée
(il n'est pas inclus),
 Step est un paramètre facultatif spécifiant la différence entre les nombres
dans la séquence ( 1 par défaut).
range(start, stop, step)

36. 3. Boucler avec For
Exemple For :
 les instructions break et continue
Vous pouvez utiliser les instructions break et continue pour modifier le flux d'une
boucle:
 Vous utilisez break pour quitter une boucle,
 Vous utilisez continue pour ignorer l'itération actuelle et continuer avec
l'itération suivante:

37. 4. La clause else avec les boucles
 Les boucles while et for peuvent également avoir une clause else en Python.
La clause else s'exécute une fois que la boucle a terminé son exécution tant
qu'elle n'a pas été terminée par break, par exemple:

38. 4. Opérateurs logiques.:
Python prend en charge les opérateurs logiques suivants :
and→ si les deux opérandes sont vrais, la condition est vraie,
par exemple, ( True and True) est True,
or→ si l'un des opérandes est vrai, la condition est vraie,
par exemple, ( True or False) est True,
not→ retourne faux si le résultat est vrai, et retourne vrai si le résultat est faux,
par exemple, not True est False.
XOR → (OU exclusif) retourne True si les deux opérandes ont des valeurs
distinctes seulement et retourne False pour le reste,

39. 6. Opérateurs au niveau du bit:(bitwise)
Vous pouvez utiliser des opérateurs au niveau du bit pour manipuler des bits de
données uniques. Les exemples de données suivants :
sera utilisé pour illustrer la signification des opérateurs au niveau du bit en
Python. Analysez les exemples ci-dessous:
 & fait au niveau du bit et , ex: x & y = 0, qui est 0000 0000 en binaire,
 | fait un bit ou , par exemple x | y = 31, qui est 0001 1111 en binaire,
 ˜ fait un pas au niveau du bit , ex: ˜ x = 240 (-16), qui est 1111 0000 en binaire,

40. 6. Opérateurs au niveau du bit:(bitwise)
Vous pouvez utiliser des opérateurs au niveau du bit pour manipuler des bits de
données uniques. Les exemples de données suivants :
Sera utilisé pour illustrer la signification des opérateurs au niveau du bit en
Python. Analysez les exemples ci-dessous:
 ^ fait un xor au niveau du bit , ex: x ^ y = 31, qui est 0001 1111 en binaire,
 >> fait un décalage à droite au niveau du bit , ex: y >> 1 = 8, qui est 0000 1000 en
binaire  (y//21 ),
 << fait un décalage à gauche au niveau du bit , ex: y << 3 = 128, qui est 1000
0000en binaire  (y*23 ),

41. 6. Opérateurs au niveau du bit:(bitwise)
Mise à jour le tableau des priorités:

42. Chapitre III: Les Listes
•Déclarer d’une liste.
•Manipuler une Liste : (append, insert, del, pop)
•Opérations sur une liste.
•Déclaration et manipulations des Listes imbriquées
42

43. 1. Déclaration d’une liste
Définition:
• Une liste stocke un ensemble d’éléments dans un ordre particulier (une
séquence). Les listes vous permettent de stocker un grand nombre de
données de différents types au même endroit.
• La liste est une séquence de valeurs appelées éléments ou éléments.
• Les éléments peuvent être de n'importe quel type de données.
• La liste est le type de données le plus polyvalent disponible dans
Python qui peut être écrit Comme une liste de valeurs séparées par des
virgules (éléments) entre crochets.
• La liste est modifiable, ce qui signifie que ses éléments peuvent être
modifiés
43

44. 1. Déclaration d’une liste
44

45. 1. Déclaration d’une liste
Création d’une Liste : Sans Constructeur:
Liste vide:
Liste d’entiers:
Liste avec différentes types de données:
Liste Imbriquée
45

46. 1. Déclaration d’une liste
Création d’une Liste : Avec Constructeur:
 Liste vide
 Liste d’entier
46

47. 2. Initialisation d’une liste
Initialiser une Liste :
 1ére méthode:
 2éme méthode:
Ou bien
47

48. 2. Accès aux éléments
Exemple :
Le premier élément de la liste:
Le dernier élément de la liste:
Les éléments entre l'index 0 et l'index 2
Les éléments après l'index 0
Les éléments avant l'index 2
48

49. 3. Parcourir la Liste:
Parcourir la liste x:
1ére méthode:
2éme méthode:
49

50. 4. Manipuler une Liste:
Modification d'une valeur de liste unique :
 villes[2] = 'meknes'
 villes[-1] = 'Ouarzazate'
Supprimer un élément dans la liste :
 del villes[3]
Modification de plusieurs valeurs de liste:
a[m:n] = <iterable>
50

51. 4. Manipuler une Liste:
Exemples Modification de plusieurs valeurs de liste:
a[1:4] = [1.1, 2.2, 3.3, 4.4, 5.5]
a[1:6] = ['Meknes']
a[2:2] = [1, 2, 3, 4, 5]
a[1] = [1, 2, 3]
51

52. 4. Manipuler une Liste:
list.append() :
Ajoute un élément à la fin de la liste. Équivalent à a[len(a):] = [x].
villes.append(123) < -- > villes + 123
Villes.append([1,2,3])
Villes.append(‘fes’)
52

53. 4. Manipuler une Liste:
list.extend(<iterable>):
Ajoute à la fin d'une liste, mais l'argument devrait être un itérable. Les éléments de <iterable> sont ajoutés
individuellement :
 Villes. Extend([1,2,3])
list.insert(<index>, <obj>):
Insère l'objet <obj> dans la liste a à <index> spécifié. Après l'appel de méthode, un [<index>] est <obj>, et les éléments de
liste restants sont poussés vers la droite :
 villes.insert(3, 'agadir')
53

54. 4. Manipuler une Liste:
list.remove(<obj>)
Supprime l'objet <obj> de la liste a. Si <obj> n'est pas dans un, une exception est levée :
 a.remove('oujda')
list.pop(index=-1)
• Cette méthode diffère de .remove () de deux manières:
1- Vous spécifiez l'index de l'élément à supprimer, plutôt que l'objet luimême.
2- La méthode renvoie une valeur : l'élément qui a été supprimé.
 a.pop()
 a.pop(2)
54

55. 4. Manipuler une Liste:
• list.clear()
• Supprime tous les éléments de la liste. Équivalent à del a[:].
• list.index(x[, start[, end]])
• Renvoie la position du premier élément de la liste dont la valeur égale x (en
commençant à compter les positions à partir de zéro). Une exception
ValueError est levée si aucun élément n'est trouvé.
• list.count(x)
• Renvoie le nombre d'éléments ayant la valeur x dans la liste.
55

56. 4. Manipuler une Liste:
• list.sort(key=None, reverse=False)
• Ordonne les éléments dans la liste (les arguments peuvent personnaliser
l'ordonnancement, voir sorted() pour leur explication).
• list.reverse()
• Inverse l'ordre des éléments dans la liste.
• list.copy()
• Renvoie une copie superficielle de la liste. Équivalent à a[:].
56

57. 5. exercices
•Convertir les éléments cette liste vec=[-4, -2, 0, 2, 4] en
valeurs absolues.
•Supprimer les espaces blancs des éléments de liste :
colors = [' red', ' green ', 'blue ‘]
•filtrer de cette liste pour exclure les nombres négatifs:
vec = [-4, -2, 0, 2, 4]
57

58. 5. exercices
• 1. définir la liste : liste =[17, 38, 10, 25, 72], puis effectuez les actions
suivantes :
– triez et affichez la liste ; //sort()
– ajoutez l’élément 12 à la liste et affichez la liste ;//extend(elts)//
append(elt)//insert(index)
– renversez et affichez la liste ;// reverse()
– affichez l’indice de l’élément 17 ; //index
– enlevez l’élément 38 et affichez la liste ; //remove
– affichez la sous-liste du 2eau 3eélément ; //[:]
– affichez la sous-liste du début au 2eélément ;//[:]
– affichez la sous-liste du 3eélément à la fin de la liste ; //[:]
– affichez la sous-liste complète de la liste ; //[:]
– affichez le dernier élément en utilisant un indiçage négatif. //
Bien remarquer que certaines méthodes de liste ne retournent rien.
58

59. 5. exercices
• 2. Initialisez truc comme une liste vide, et machin comme une liste de
cinq flottants nuls.
• Affichez ces listes.
• Utilisez la fonction range() pour afficher :
– les entiers de 0 à 3 ;
– les entiers de 4 à 7 ;
– les entiers de 2 à 8 par pas de 2.
• Définir chose comme une liste des entiers de 0 à 5 et testez
l’appartenance des éléments 3 et 6 à chose.
59

60. 5. exercices
3. Utilisez une liste pour ajouter 3 à chaque élément d’une liste d’entiers
de 0 à 5.
4. Utilisez une liste pour ajouter 3 à chaque élément d’une liste d’entiers
de 0 à 5, mais seulement si l’élément est supérieur ou égal à 2.
6. Utilisez une liste pour calculer la somme d’une liste d’entiers de 0 à
9.
60

61. 6. Les listes imbriquées:
61

62. 6. Les listes imbriquées:
62

63. 6. Les listes imbriquées:
63

64. 6. Les listes imbriquées:
64
L = ['a', 'b',
['cc', 'dd',
['eee', 'fff']],
'g', 'h']

65. 6. Les listes imbriquées:
65
L = ['a', 'b',
['cc', 'dd',
['eee', 'fff']],
'g', 'h']

66. 6. Les listes imbriquées:
66

67. 6. Les listes imbriquées:
67
 Modifier la valeur de l'élément de liste imbriquée :
L = ['a', ['bb', 'cc'], 'd']
L[1][1] = 0
print(L)
 Ajouter des éléments à une liste imbriquée:
 L = ['a', ['bb', 'cc'], 'd']
 L[1].append('xx')

68. 6. Les listes imbriquées:
68
L = ['a', ['bb', 'cc'], 'd']
L[1].insert(0,'xx’)
L = ['a', ['bb', 'cc'], 'd']
L[1].extend([1,2,3])
L = ['a', ['bb', 'cc', 'dd'], 'e’ ,['bb', 'cc', 'dd'] ]
x = L[1].pop(1)
L = ['a', ['bb', 'cc', 'dd'], 'e']
del L[1][1]
L = ['a', ['bb', 'cc', 'dd'], 'e']
L[1].remove('cc')

69. 6. Les listes imbriquées:
69
#Exemple 1
a = [[1, 2, 3, 4], [5, 6], [7, 8, 9]]
s = 0
for row in a:
for col in row:
s += col
print(s)
#Exemple 2
enclos1 = ['girafe', 4]
enclos2 = ['tigre', 2]
enclos3 = ['singe', 5]
zoo = [enclos1, enclos2, enclos3]
print(zoo)

70. Chapitre IV: LesTuples
•Utilisé des tuples
•Différences entre tuple et liste.
•Différente déclaration d’un tuple.
•Manipulation des tuples.
•Opérations sur un tuple.
•Imbrications des tuples.
•Conversion d’un tuple en liste et vise versa.
70

71. 1. DéfinitionTuple, Déclaration et Initialisation
C’est Quoi un tuple:
• Tuples est une séquence de valeurs contenant de nombreux éléments, similaire à
la liste.
• Contrairement à la liste, Tuples est un type de données immuables, toutes les
mises à jour sur leTuple créent une nouvelle entité dans la mémoire.
• Pour écrire un Tuple, vous devez mettre les éléments entre parenthèses () et les
séparer par une virgule. Ces éléments de la liste sont indexés avec l’index de 0.
Utilité d’un tuple:
• Protéger des données qui ne doivent pas êtres modifiées lors de l’exécution d’un
programme.
• Effectuer des affectations multiples
• Permettre le renvoi de plusieurs résultats d’une fonction.
71

72. 1. DéfinitionTuple, Déclaration et Initialisation
Déclaration et Initialisation:
Création d’un tuple vide tup = ()
Création d’un tuple avec
des éléments
tup=(1, 2,True, "a string", (3, 4), [5, 6], None)
Ou bien
tup= 1, 2,True, "a string", (3, 4), [5, 6], None,
Création d’un tuple avec
un seul élément
tup = (10,) ou bien
tup = 10,
Création d’un tuple avec
un itérable
tup = tuple('Hello')
tup1 = tuple((‘a’,’b’,’c’))
tup2 = tuple(range(1,5))
tup3 = tuple(tup1)
72

73. 1. DéfinitionTuple, Déclaration et Initialisation
Déclaration et Initialisation:
les éléments d' un tuple peuvent être des variables , pas seulement des
littéraux. De plus, elles peuvent être des expressions si elles se trouvent du côté
droit de l'opérateur d'affectation.
• var = 123
• t1 = (1, )
• t2 = (2, )
• t3 = (3, var)
• t1, t2, t3 = t2, t3, t1
• print(t1, t2, t3)
Il montre trois tuples en interaction - en effet, les valeurs qui y sont stockées
"circulent" - t1 devient t2, t2 devient t3 et t3 devient t1. 73

74. 2. Comparaison entreTuple et List
List etTuple sont une séquence des éléments. Elles sont des différences comme
suivantes :
• Lorsque vous écrivez une List, vous utilisez utiliser des crochets [], mais vous
utilisez des parenthèses () en écrivant uneTuple.
• La liste est un type de données modifiable (mutable), vous pouvez utiliser la
méthode append() pour ajouter l'élément à List ou utiliser la méthode remove()
pour supprimer des éléments de List sans créer d'autre entité 'List' sur la
mémoire.
UnTuple Une Liste
tup=(10, 10.2,'H',"TDI") Lst=(10, 10.2,'H',"TDI")
74

75. 2. Comparaison entreTuple et List
• Tuple est un objet immuable (immutable), elle n'a pas les méthodes append(),
remove(), ...comme list. Vous pouvez penser que certaines méthodes, ou
opérateurs sont utilisés pour mettre à jour Tuple mais le fait qu'elle est basée sur
laTuple originale pour créer une nouvelleTuple.
UnTuple (est immutable) Une Liste(est mutable)
Exemple : Exemple:
75

76. 2. Comparaison entreTuple et List
UnTuple (est immutable) Une Liste(est mutable)
Résultat :
Adresse du tuple est changé, après
et avant l’ajout l’adresse de la liste
est changé.
Résultat:
Adresse de la liste n’a pas changé,
après et avant l’ajout l’adresse de la
liste et la même.
76

77. 3. Accéder aux éléments de tuples.
Utiliser La boucle For:
Utiliser L’index : (index positive)
Utiliser L’index : (index négative)
77

78. 3. Accéder aux éléments de tuples.
• Comme pour les listes, pour accéder aux éléments contenus dans un tuple
on utilise l’index
78

79. 3. Accéder aux éléments de tuples.
Accéder à une partie d’un tuple : accès à une tranche = slice [n : p ]
Sens de slice doit être vu de gauche vers droite
[:] Accès à tous les éléments
[n:n] Pas slice de n à n-1
[n:p] de n à p-1 vers droite pour( t =tuple (0<=n< p<len (t) )
[p:n] de p à n-1 slice vide, le resultat est tuple vide () pour : t =tuple (0<=n<p< len (t)
[n:p] Pour t =tuple (-len (t)<=n<p<-1 ) , slice de n à p-1
[p:n] Pour t =tuple (-len (t)<=n<p<-1 ) , pas slice de p à, résultat slice vide ()
[n:p:pas ] pas=déplacement
exemple [::-1] : Affichage inverse tuple
79

80. 3. Accéder aux éléments de tuples.
Accéder à une partie d’un tuple : Il est possible d’accéder à des ‘sous- tuple’
en précisant la tranche souhaitée. (utilisation de slice).
80

81. 4. Operations sur lesTuples.
Longueur d’un tuple : La longueur d’un tuple est le nombre d’éléments qu’il
contient. Comme pour les listes c’est la fonction len qui permet d’obtenir la
longueur d’un tuple.
• Exemple:
Concaténation : La concaténation est l’opération qui consiste à construire un
tuple en additionnant deux ou plusieurs tuples.
• exemple
81

82. 4. Operations lesTuples.
Répétition : L’opérateur * employé avec un nombre entier et un tuple
construit une nouveau tuple en répétant le tuple autant de fois que l’indique
le nombre.
Exemple
• Test si existe un élément dans un tuple
Exist : in Not exist : not in
82

83. 5. Manipulations sur lesTuples.
• ConvertirTuple vers List:
• Convertir List versTuple:
• Maximum et Minimum d’unTuple:
83

84. 5. Manipulations sur lesTuples.
• Retourne le nombre de fois la valeur dans un tuple:
• Retourne 1 er index de la valeur dans un tuple:
84

85. 5. Manipulations sur lesTuples.
• L'ajout, la modification et la suppression des éléments de tuple individuels n'est
pas possible. possible, mais vous pouvez :
Supprimer le tuple : del <nom_tuple >
Exemple : del tup1
Ajout et modification et suppression détournée:
ConvertirTuple vers List
 Ajout, modifier ou supprimer de la liste
Convertir la liste vers tuple
Exemple
85

86. ChapitreV: Les Dictionnaires
• Définition des dictionnaires, Différence entre un dictionnaire, tuple
et liste.
• Définir les éléments d’un dictionnaire: clé, valeur
• Déclarer un Dictionnaire:
Accès par clé.
Lister les éléments d’un dict.
Recherche( les méthodes Keys(), items, values(),….).
Les fonctions sorted().
Modification, ajout et suppression d’une valeur d’un dict.
Convertir un tuple en dictionnaire et vice versa.
86

87. 1. Définition de dictionnaire
C’est Quoi un Dictionnaire:
• Le dictionnaire est une autre structure de données Python. Ce n'est pas un type
de séquence (mais peut être facilement adapté au traitement de séquence) et il
est modifiable .
• Un dictionnaire est une structure de données, non ordonnée, qui permet de
stocker des données.
• Les éléments du dictionnaire sont constitués de deux parties: une clé et une
valeur ( key/value)
• Vous pouvez les utiliser pour organiser les données en structures hiérarchiques.
• Par exemple, un dictionnaire peut contenir un carnet d'adresses et on accède à
chaque contact en précisant son nom.
{nom: ( prénom, adresse, téléphone)}
87

88. 1. Définition de dictionnaire
Définir les éléments d’un dictionnaire: clé, valeur
Clés Valeurs
Code
Nom
Age
100
ALAMI
30
88

89. 2. Déclaration et Initialisation
Déclaration et Initialisation:
Création d’un Dictionnaire vide dic = {}
Ou bien
dic = dict()
Création d’un tuple avec des
éléments
Les clés sont: Filiere,Group, Annee
Les valeurs sont :TDI, A, 1
dic = {'Filiere':'TDI','Group':'A','Annee':1}
Ou bien
dic = {}
dic['Filiere']='TDI'
dic['Group']='A'
dic['Annee']=1
89

90. 3. Manipulation les dictionnaires
Ajouter un élément:
Autre méthode en utilisant le update() pour l’ajout:
Supprimer un élément:
Supprimer le dernier élément d’un dictionnaire/ tous les éléments:
Longueurs d’un Dictionnaire: Copie un Dictionnaire :
dic.update({“niveau" : “TS"})
Ou bien
del dic [‘ville']
90

91. 3. Manipulation les dictionnaires
Listes des clés:
Listes des valeurs:
Listes des valeurs et des clés:
Trier un dictionnaire:
Accéder à un élément :
91

92. 3. Manipulation des dictionnaires
Convertir un Dictionnaire à une liste:
Convertir un Dictionnaire à un tuple:
List des Dictionnaires :
Tuple des Dictionnaires :
Aussi:
Aussi:
92

93. 4. Parcourir les dictionnaires
Parcourir un dictionnaire par clé:
Parcourir un dictionnaire par valeur:
Parcourir un dictionnaire par valeur et clé:
93

94. 4. Parcourir les dictionnaires
Parcourir un dictionnaire par clé:
Parcourir un dictionnaire par valeur:
Parcourir un dictionnaire par valeur et clé:
Résultat
Filiere
Group
Annee
Résultat
TDI
A
1
Résultat
Filiere TDI
Group A
Annee 1
Ou Bien:
Ou Bien:
94

95. 5. Opération sur dictionnaires
L’opérateur in et not in:
• dictionary = {"cat" : "chat", "dog" : "chien", "horse" : "cheval"}
• words = ['cat', 'lion', 'horse']
Exemple Résultat
95

96. 5. Opération sur dictionnaires
Tuples et dictionnaires peuvent fonctionner ensemble
Nous avons préparé un exemple simple, montrant comment les tuples et les
dictionnaires peuvent fonctionner ensemble.
Imaginons le problème suivant:
 vous avez besoin d'un programme pour évaluer les notes moyennes des
élèves;
 le programme doit demander le nom de l'élève, suivi de son score unique;
 les noms peuvent être entrés dans n'importe quel ordre;
 la saisie d'un nom vide termine la saisie des données;
 une liste de tous les noms, ainsi que le score moyen évalué, doivent ensuite
être émis.
96

97. 5. Opération sur dictionnaires
Tuples et dictionnaires peuvent fonctionner ensemble
97

98. 6. Dictionnaires Imbriqué
Déclaration d’un dictionnaire:
Accéder aux éléments:
Exemple:
dict_imbriquer = { 'dict_1’: { 'clé_1': 'valeur_1’},
'dict_2’: { 'clé_2': 'valeur_2’, ‘clé_3’:’valeur_3’ } }
print(dict_imbriquer ['dict_1']['clé_1'])
print(dict_imbriquer ['dict_2']['clé_3'])
stagiaire = {1: {'name': 'Alex','age': '15'},2: {'name': 'Bob','age':
'29’}}
print(stagiaire[1]['name’]) #Resultat Alex
print(stagiaire[2]['age’]) #Resultat 29 98

99. 6. Dictionnaires Imbriqué
99

100. ChapitreVI: Les Chaines de Caractères (CDC)
•Définition CDC
•Création et initialisation
•Accéder aux Caractères
•Manipulation des CDC
100

101. 1. Définition CDC & Création
C’est-à-dire quoi une Chaine de caractère :
• Une chaîne est une séquence de caractères.
• Une chaîne en python comprend zéro ou plusieurs caractères écrits entre
guillemets simples ' ' ou guillemets doubles " ".
Créer une chaine de caractère :
Initialisation multilignes :
• Vous pouvez créer une chaîne multiligne
à l'aide de guillemets triples: """ """ ou
''' '''.
101

102. 3. Accéder aux Caractères:
Accès par index:
• Vous pouvez accéder à des caractères individuels d'une chaîne à l'aide d'un index
entre crochets. L'indexation des chaînes commence à 0.
• Vous pouvez également accéder à une chaîne par indexation négative. Un index
de chaîne négatif compte à partir de la fin de la chaîne.
102

103. 3. Accéder aux Caractères:
Trancher une chaîne :
• Un segment d'une chaîne s'appelle une tranche et vous pouvez en extraire
une à l'aide d'un opérateur de tranche. Une tranche de chaîne est également
une chaîne.
• L'opérateur de tranche [n: m] renvoie la partie de la chaîne de l'élément «n-
ième» à l'élément «m-ième », y compris le premier mais à l'exclusion du
dernier.
103

104. 3. Accéder aux Caractères:
104

105. 3. Accéder aux Caractères:
105

106. 3. Accéder aux Caractères:
106

107. 3. Accéder aux Caractères:
Taille de pas négative:
L'omission de l'index de démarrage démarre la tranche à partir de l'index 0.
Signification, S [: stop] est équivalent à S [0: stop]
Tranche au début et à la fin:
Tandis que, l'omission de l'index d'arrêt étend la tranche jusqu'à la fin de la
chaîne. Signification, S[start:] est équivalent à S[start: len (S)]
107

108. 2. Manipulation des chaines des caractères:
Le constructeur str ():
• Vous pouvez convertir presque n'importe quel objet en Python en chaîne à l'aide
d'un constructeur de type appelé str ().
• Exemple :
Modifier une chaine:
Comment Faire ??
108

109. 2. Manipulation des chaines des caractères:
Concaténation des chaines
La Répétition :
109

110. 2. Manipulation des chaines des caractères:
Longueur d’une chaine :
RemplacerTexte dans une chaine :
Split des chaines :
110

111. 2. Manipulation des chaines des caractères:
Join des chaines :
Modifier la casse d’une chaine :
Lower():
111

112. 2. Manipulation des chaines des caractères:
Upper() :
Capitalize():
Swapcase():
Title()
112

113. 2. Manipulation des chaines des caractères:
format():
113

114. 2. Manipulation des chaines des caractères:
Vérifier si une chaine existe dans une autre :
• Pour rechercher un texte spécifique dans une chaîne, utilisez la méthode find () et
rfind (). Il renvoie l'index le plus bas de la chaîne où se trouve la sous-chaîne.
114

115. 2. Manipulation des chaines des caractères:
Parcourir une chaine :
Séquence d'échappement Python :
• Vous pouvez utiliser des guillemets à l'intérieur d'une chaîne, tant qu'ils ne
correspondent pas aux guillemets entourant la chaîne.
115

116. 116

117. 117

118. ChapitreVII: Fonctions & Procédures
•Déclaration des fonctions et procédures.
•Appel des fonctions et procédures.
•Passages des paramètres par adresse et par
valeurs.
•Instruction Return :
•Sans expression => La valeur None.
•Avec expression.
•Définir la différences entre fonction et méthode.
118

119. 1. Déclaration des fonctions et procédures
Intérêt des fonctions et procédures:
• Si un fragment particulier du code commence à apparaître à plusieurs
endroits, envisagez la possibilité de l'isoler sous la forme d'une fonction.
• Optimise le code, minimise la répétition du code plusieurs fois dans votre
programme.
• Un bon développeur attentif divise le code (ou plus précisément : le
problème) en morceaux bien isolés et les code chacun sous la forme d'une
fonction.
• Le processus décrit ici est souvent appelé decomposition.
• Si un morceau de code devient si volumineux que sa lecture et sa sous-
estimation peuvent causer un problème, envisagez de le diviser en
problèmes distincts et plus petits et implémentez chacun d'eux sous la
forme d'une fonction distincte
• Les fonctions peuvent avoir des paramètres et des valeurs de retour.
119

120. 1. Déclaration des fonctions et procédures
D'où viennent les fonctions ?
• En général, les fonctions proviennent d'au moins trois endroits
• à partir de Python lui-même - de nombreuses fonctions (comme print ()) font partie intégrante de
Python et sont toujours disponibles sans effort supplémentaire de la part du programmeur ; nous
appelons ces fonctions des fonctions intégrées ; https://docs.python.org/3/library/functions.html .
• à partir des modules préinstallés de Python - de nombreuses fonctions, très utiles, mais utilisées
beaucoup moins souvent que celles intégrées, sont disponibles dans un certain nombre de
modules installés avec Python ; l'utilisation de ces fonctions nécessite quelques étapes
supplémentaires de la part du programmeur afin de les rendre entièrement accessibles (nous
vous en parlerons dans un moment);
• directement à partir de votre code - vous pouvez écrire vos propres fonctions, les placer dans
votre code et les utiliser librement ;
120

121. 1. Déclaration des fonctions et procédures
Déclaration d’une Fonction:
• Déclaration:
 Il commence toujours par le mot-clé def (pour définir)
 Ensuite def le nom de la fonction (les règles pour
nommer les fonctions sont exactement les mêmes
que pour nommer les variables).
 Après le nom de la fonction, il y a une place pour une paire de parenthèses (elles ne
contiennent rien ici, mais cela changera bientôt).
 La ligne doit être terminée par deux points ;
 La ligne directement après def commence le corps de la fonction - un couple (au
moins
un) d’instructions nécessairement imbriquées, qui seront exécutées chaque fois que la
fonction est invoquée ; remarque : la fonction se termine là où se termine
l’imbrication, vous devez donc être prudent.
• Exemple:
121

122. 1. Déclaration des fonctions et procédures
Déclaration d’une Fonction:
• Déclaration:
Vous pouvez définir votre propre fonction à l'aide du mot - clé def et de la syntaxe
suivante:
Vous pouvez définir une fonction qui ne prend aucun argument, par exemple :
Vous pouvez également définir une fonction qui accepte des arguments, tout
comme la fonction à un paramètre ci-dessous:
LAMRANI KAOUTAR 122

123. 1. Déclaration des fonctions et procédures
Déclaration d’une Fonction:
l’invocation de la fonction :
Vous ne devez pas invoquer une fonction qui n'est pas connue au moment de
l'invocation N'essayez pas de forcer Python à rechercher des fonctions que vous
n'avez pas fournies Vous ne devez pas avoir une fonction et une variable du
même nom
123

124. 1. Déclaration des fonctions et procédures
Les Fonctions paramétrées:
• les paramètres n'existent qu'à l'intérieur des fonctions dans lesquelles ils ont été
définis, et le seul endroit où le paramètre peut être défini est un espace entre une paire
de parenthèses dans l'instruction def;
• L'attribution d'une valeur au paramètre se fait au moment de l'appel de la fonction,
en spécifiant l'argument correspondant.
• Les paramètres vivent à l'intérieur des fonctions (c'est leur environnement naturel)
• Les arguments existent en dehors des fonctions et sont porteurs de valeurs
passées aux paramètres correspondants
• La spécification d'un ou plusieurs paramètres dans la définition d'une fonction est
également une exigence, et vous devez la remplir lors de l'appel. Vous devez fournir
autant d'arguments qu'il y a de paramètres définis
124

125. 1. Déclaration des fonctions et procédures
Les Fonctions paramétrées:
• Il est légal et possible d'avoir une variable nommée de la même manière qu'un paramètre de
fonction.
• Une fonction peut avoir autant de paramètres que vous le souhaitez,
• Cela signifie également que l'invocation de la fonction nécessitera deux arguments.
125

126. 1. Déclaration des fonctions et procédures
Passage de paramètre positionnel
Une technique qui attribue le ième (premier, deuxième, etc.) argument au
paramètre de la fonction iième (premier, deuxième et ainsi de suite) est appelée
passage de paramètre positionnel, tandis que les arguments passés de cette
manière sont appelés arguments positionnels.
126

127. 1. Déclaration des fonctions et procédures
Argument de mot-clé passant
Python propose une autre convention pour le passage d'arguments, où la
signification de l'argument est dictée par son nom, et non par sa position - c'est ce
qu'on appelle le passage d'argument par mot clé.
127

128. 1. Déclaration des fonctions et procédures
Mélanger les arguments de position et de mot-clé
• vous devez mettre les arguments positionnels avant les arguments mot-clé.
• arguments positionnels ne doivent pas suivre les arguments des mots clés.
128

129. 1. Déclaration des fonctions et procédures
Fonctions paramétrées - plus de détails
Ces arguments peuvent avoir leurs valeurs par défaut (prédéfinies)
129

130. 1. Déclaration des fonctions et procédures
Effets et résultats: l' instruction de retour
Le return instruction a deux variantes différentes - considérons-les séparément
• revenir sans expression
• Le premier se compose du mot-clé lui-même
, sans que rien ne le suive.
• Provoque l' arrêt immédiat de
l'exécution de la fonction et un retour
instantané (d'où le nom) au point d'invocation .
• Si une fonction n'est pas destinée à produire un résultat, l' utilisation de le return
instruction n'est pas obligatoire - elle sera exécutée implicitement à la fin de la
fonction.
• l'utiliser pour terminer les activités
d'une fonction à la demande
130

131. 1. Déclaration des fonctions et procédures
Effets et résultats: l' instruction de retour
La deuxième return variante est complétée par une expression :
Il y a deux conséquences à l'utiliser:
 il provoque l' arrêt immédiat de l'exécution de la fonction (rien de nouveau
par rapport à la première variante)
 de plus, la fonction évaluera la valeur de l'expression et la renverra (d'où le
nom une fois de plus) comme résultat de la fonction .
131
revenir avec une expression

132. 1. Déclaration des fonctions et procédures
Effets et résultats: l' instruction de retour
132
revenir avec une expression

133. 1. Déclaration des fonctions et procédures
Quelques mots sur None
133
• Laissez-nous vous présenter une valeur très curieuse (pour être honnête, une valeur nulle)
nommée None.
• Ses données ne représentent aucune valeur raisonnable - en fait, ce n'est pas du tout une
valeur; par conséquent, il ne doit participer à aucune expression .
Il n'y a que deux types de circonstances qui None peuvent être utilisées en toute sécurité:
 lorsque vous l' affectez à une variable (ou le retournez comme résultat d'une fonction )
 lorsque vous le comparez à une variable pour diagnostiquer son état interne.
• N'oubliez pas ceci: si une fonction ne retourne pas une certaine valeur en utilisant
une return clause d'expression, on suppose qu'elle renvoie implicitement None .

134. 1. Déclaration des fonctions et procédures
Effets et résultats: listes et fonctions
une liste peut-elle être envoyée à une fonction comme argument
et invoqué comme ceci:
134

135. 1. Déclaration des fonctions et procédures
Effets et résultats: listes et fonctions
une liste peut-elle être un résultat de fonction?
La sortie du programme sera comme ceci:
[4, 3, 2, 1, 0]
135

136. 1. Déclaration des fonctions et procédures
Fonctions et champs d'application
• La portée d'un nom (par exemple, un nom de variable) est la partie d'un code où le nom
est correctement reconnaissable.
• la portée du paramètre d'une fonction est la fonction elle-même. Le paramètre est
inaccessible en dehors de la fonction.
136
• Le programme échouera lors de son exécution. Le message d'erreur indiquera

137. 1. Déclaration des fonctions et procédures
Fonctions et champs d'application
• Commençons par vérifier si une variable créée à l'extérieur d'une fonction est visible à
l'intérieur des fonctions. En d'autres termes, le nom d'une variable se propage-t-il dans le
corps d'une fonction?
137
• La réponse est: une variable existant en dehors d'une fonction a une portée à
l'intérieur des corps des fonctions

138. 1. Déclaration des fonctions et procédures
Fonctions et champs d'application
138
• Une variable existant en dehors d'une fonction a une portée à l'intérieur des corps des
fonctions, à l'exclusion de celles d'entre elles qui définissent une variable du même nom.
• Cela signifie également que la portée d'une variable existante en dehors d'une fonction
n'est prise en charge que lors de l'obtention de sa valeur (lecture). L'attribution d'une valeur
force la création de la propre variable de la fonction

139. 1. Déclaration des fonctions et procédures
Fonctions et étendues: le mot-clé global
139
Il existe une méthode Python spéciale qui peut étendre la portée d'une variable
d'une manière qui inclut les corps des fonctions (même si vous voulez non
seulement lire les valeurs, mais aussi les modifier)
Un tel effet est provoqué par un mot-clé nommé global:
.
En d'autres termes, ce nom devient global (il a une portée globale et peu importe
qu'il fasse l'objet d'une lecture ou d'une affectation).

140. 1. Déclaration des fonctions et procédures
Fonctions et étendues: le mot-clé global
Nous avons ajouté global à la fonction.
Le code génère désormais:
140

141. 1. Déclaration des fonctions et procédures
Comment la fonction interagit avec ses arguments
141
• La conclusion est évidente - la modification de la valeur du paramètre ne se
propage pas en dehors de la fonction (en tout cas, pas lorsque la variable est
un scalaire, comme dans l'exemple).
• Cela signifie également qu'une fonction reçoit la valeur de l'argument, pas
l'argument lui-même. Cela est vrai pour les scalaires.

142. 1. Déclaration des fonctions et procédures
Comment la fonction interagit avec ses arguments
142
Essayons:
 si l'argument est une liste, la modification de la valeur du paramètre
correspondant n'affecte pas la liste (rappelez-vous: les variables contenant
des listes sont stockées différemment des scalaires)
 mais si vous modifiez une liste identifiée par le paramètre (remarque: la liste,
pas le paramètre!), la liste reflétera le changement.

143. 1. Déclaration des fonctions et procédures
143
1. Une fonction peut appeler d'autres fonctions ou même elle-même. Lorsqu'une
fonction s'appelle elle-même, cette situation est connue sous le nom
de récursivité , et la fonction qui s'appelle elle-même et contient une
condition de terminaison spécifiée (c'est-à-dire le cas de base - une condition
qui ne dit pas à la fonction de faire d'autres appels à cette fonction) est
appelée fonction récursive .
2. Vous pouvez utiliser des fonctions récursives en Python pour écrire du code
propre et élégant et le diviser en morceaux plus petits et organisés . D'un
autre côté, vous devez être très prudent car il pourrait être facile de faire une
erreur et de créer une fonction qui ne se termine jamais . Vous devez
également vous rappeler que les appels récursifs consomment beaucoup
de mémoire et peuvent donc parfois être inefficaces
Les Fonctions Récursives :