[Link].

FR

SUPPORT DE COURS DE PYTHON V1.0

GIOVANI@[Link]

ZG
GETECH
INTRODUCTION
La démarche du programmeur
Le programmeur, comme un mathématicien, ingénieur ou scientifique, utilise des
langages formels, conçoit des systèmes, et résout des problèmes de manière
structurée. Son travail consiste à reformuler des problèmes, imaginer des solutions
innovantes, et les exprimer de façon claire. La programmation est une démarche
méthodique de traduction d’idées abstraites en instructions détaillées, formant un
algorithme compréhensible pour une machine.

L’ordinateur fonctionne uniquement avec des signaux binaires (0 et 1) car il ne

peut traiter que deux états électriques. Toute information, qu’il s’agisse de textes,
images ou programmes, doit donc être convertie en format binaire. Le "langage
machine" est ainsi une longue suite de bits incompréhensible pour les humains.
Pour communiquer avec un ordinateur, on utilise des langages de programmation,
qui emploient des mots-clés et des règles compréhensibles pour nous. Ces langages
sont traduits en langage machine par un interpréteur ou un compilateur, rendant le
programme exécutable par l’ordinateur.

Python est un langage de programmation très populaire, connu pour sa simplicité

et sa lisibilité. Il est souvent décrit comme un langage "tout-usage", car il peut être
utilisé pour une grande variété de tâches, allant du développement web à la
science des données en passant par l'automatisation de tâches.

Pourquoi Python est-il si populaire ?

 Facile à apprendre: La syntaxe de Python est conçue pour ressembler au

langage naturel, ce qui le rend plus facile à apprendre pour les débutants.
 Polyvalent: Python peut être utilisé pour créer toutes sortes d'applications,
des scripts simples aux logiciels complexes.
 Grande communauté: Python bénéficie d'une communauté d'utilisateurs très
active, ce qui signifie qu'il existe une abondance de ressources, de
bibliothèques et de tutoriels disponibles.
 Open-source: Python est un logiciel libre, ce qui signifie qu'il est gratuit à
utiliser et à distribuer.

À quoi sert Python ?

Voici quelques exemples d'applications de Python :

 Développement web: Des frameworks comme Django et Flask permettent de

créer des sites web et des applications web rapidement et efficacement.

P a g e 1 | 28
  Science des données et machine learning: Des bibliothèques comme NumPy,
Pandas et scikit-learn sont largement utilisées pour l'analyse de données, la
visualisation et le machine learning.
 Automatisation: Python est excellent pour automatiser des tâches
répétitives, comme la manipulation de fichiers, l'envoi d'e-mails ou la
récupération de données sur Internet.
 Développement de jeux: Des moteurs de jeu comme Pygame permettent de
créer des jeux vidéo 2D.
 Scripting système: Python peut être utilisé pour écrire des scripts pour
administrer des systèmes d'exploitation.

CHAP1 : Calculer avec Python

1.1 Exemples de codes
>>> 5+3
>>> 2 – 9 # les espaces sont optionnels
>>> 7 + 3 * 4 # la hiérarchie des opérations mathématiques
# est-elle respectée ?
>>> (7+3)*4
>>> 20 / 3 # attention : ceci fonctionnerait différemment sous Python 2
>>> 20 // 3
>>> 5**2 # affiche 25
Les opérateurs arithmétiques pour l’addition, la soustraction, la multiplication et
la division sont respectivement +, -, * et /.
>>> 20.5 / 3
>>> 8,7 / 5 # Erreur !

1.2 Données et variables

Sous Python, les noms de variables doivent en outre obéir à quelques règles simples
:
• Un nom de variable est une séquence de lettres (a → z, A → Z) et de chiffres (0 →
9), qui doit toujours commencer par une lettre.
• Seules les lettres ordinaires sont autorisées. Les lettres accentuées, les cédilles,
les espaces, les caractères spéciaux tels que $, #, @, etc. sont interdits, a l’exception
du caractère
_ (souligne).
• La casse est significative (les caractères majuscules et minuscules sont distingués).

Attention : Joseph, joseph, JOSEPH sont donc des variables différentes. Soyez
attentifs !
En plus de ces règles, il faut encore ajouter que vous ne pouvez pas utiliser comme
nom de variables les 33 ≪ mots réserves ≫ ci-dessous (ils sont utilisés par le langage
lui-même) :

P a g e 2 | 28
and as assert break class continue def
del elif else except False finally for
from global if import in is lambda
None nonlocal not or pass raise return
True try while with yield

1.3 Affectation (ou assignation)

En Python comme dans de nombreux autres langages, l’opération d’affectation est
représentée par le signe égal :
>>> n = 7 # définir n et lui donner la valeur 7
>>> msg = "Quoi de neuf ?" # affecter la valeur "Quoi de neuf ?" à msg
>>> pi = 3.14159 # assigner sa valeur à la variable pi

1.4 Afficher la valeur d’une variable

Pour afficher leur valeur a l’écran, il existe deux possibilités. La première consiste
à entrer au clavier le nom de la variable, puis <Enter>. Python répond en affichant
la valeur correspondante
:
>>> n
7
>>> msg
'Quoi de neuf ?'
>>> pi
3.14159
Il s’agit cependant là d’une fonctionnalité secondaire de l’interpréteur, qui est
destinée à vous faciliter la vie lorsque vous faites de simples exercices a la ligne de
commande. A l’intérieur d’un programme, vous utiliserez toujours la fonction
print()

>>> print(msg)
Quoi de neuf ?
>>> print(n)
7

1.5 Typage des variables

Les nombres

 Entiers (int): Représentent les nombres entiers.

Code Python

age = 30
P a g e 3 | 28
 nombre_de_chats = 2
print(type(age)) # Affiche <class 'int'>

 Nombres à virgule flottante (float): Représentent les nombres à virgule.

Code Python

pi = 3.14159
prix = 9.99
print(type(pi)) # Affiche <class 'float'>

Les chaînes de caractères (str)

 Texte:

Code Python

nom = "Alice"
phrase = "Bonjour, monde!"
print(type(nom)) # Affiche <class 'str'>

 Les booléens (bool)

Vrai ou faux:

Code Python

est_majeur = True
soleil_brille = False
print(type(est_majeur)) # Affiche <class 'bool'>

Les listes (list)

 Collections ordonnées d'éléments:

Code Python

fruits = ["pomme", "banane", "orange"]

nombres = [1, 2, 3, 4, 5]
print(type(fruits)) # Affiche <class 'list'>

Les tuples (tuple)

 Collections ordonnées et immuables d'éléments:

P a g e 4 | 28
 Code Python

coordonnees = (3, 4) # Un point dans un plan

jours_semaine = ("lundi", "mardi", "mercredi", "jeudi", "vendredi", "samedi",
"dimanche")
print(type(coordonnees)) # Affiche <class 'tuple'>

Les dictionnaires (dict)

 Collections non ordonnées de paires clé-valeur:

Code Python

personne = {"nom": "Dupont", "age": 35, "ville": "Paris"}

print(type(personne)) # Affiche <class 'dict'>

Les ensembles (set)

 Collections non ordonnées d'éléments uniques:

Python

mon_ensemble = {1, 2, 2, 3, 4} # Le 2 n'apparaîtra qu'une fois

print(type(mon_ensemble)) # Affiche <class 'set'>

Quelques opérations de base sur les listes:

Code Python
ma_liste = [1, 2, 3, 4]
# Accéder à un élément
print(ma_liste[0]) # Affiche 1
# Modifier un élément
ma_liste[1] = 5
# Ajouter un élément à la fin
ma_liste.append(6)
# Supprimer un élément
ma_liste.remove(3)

Pourquoi est-ce important de connaître les types de données ?

 Opérations: Les opérations possibles dépendent du type de données (par

exemple, on peut additionner des nombres mais pas des chaînes de
caractères).
P a g e 5 | 28
  Conversions: Il est parfois nécessaire de convertir un type en un autre (par
exemple, convertir une chaîne en entier).
 Structures de données: Les différents types de données permettent de
construire des structures de données plus complexes (par exemple, des listes
de dictionnaires).

Chaque type de données a ses propres caractéristiques et utilisations. Comprendre

ces différences est essentiel pour écrire du code Python efficace et correct.

1.6 Affectations multiples

Sous Python, on peut assigner une valeur à plusieurs variables simultanément.
Exemple :
>>> x = y = 7
>>> x
7
>>> y
7
On peut aussi effectuer des affectations parallèles à l’aide d’un seul operateur :
>>> a, b = 4, 8.33
>>> a
4
>>> b
8.33
Dans cet exemple, les variables a et b prennent simultanément les nouvelles valeurs
4 et 8,33.

1.7 Priorité des opérations

Lorsqu’il y a plus d’un opérateur dans une expression, l’ordre dans lequel les
opérations doivent être effectuées dépend de règles de priorité. Sous Python, les
règles de priorité sont les mêmes que celles qui vous ont été enseignées au cours de
mathématiques. Vous pouvez les mémoriser aisément à l’aide d’un ≪ truc ≫
mnémotechnique, l’acronyme PEMDAS :
• P pour parenthèses. Ce sont elles qui ont la plus haute priorité. Elles vous
permettent donc de ≪ forcer ≫ l’évaluation d’une expression dans l’ordre que vous
voulez.
Ainsi 2*(3-1) = 4, et (1+1)**(5-2) = 8.
• E pour exposants. Les exposants sont évalués ensuite, avant les autres opérations.
Ainsi 2**1+1 = 3 (et non 4), et 3*1**10 = 3 (et non 59049 !).

P a g e 6 | 28
• M et D pour multiplication et division, qui ont la même priorité. Elles sont évaluées
avant l’addition A et la soustraction S, lesquelles sont donc effectuées en dernier
lieu.
Ainsi 2*3-1 = 5 (plutôt que 4), et 2/3-1 = -0.3333... (Plutôt que 1.0).
• Si deux opérateurs ont la même priorité, l’évaluation est effectuée de gauche à
droite.
Ainsi dans l’expression 59*100//60, la multiplication est effectuée en premier, et la
machine doit donc ensuite effectuer 5900//60, ce qui donne 98. Si la division était
effectuée en premier, le résultat serait 59 (rappelez-vous ici que l’operateur //
effectue une division entière, et vérifiez en effectuant 59*(100//60)).

CHAP2 Les données alphanumériques

2.1 Accès aux caractères individuels d’une chaîne

Les chaines de caractères constituent un cas particulier d’un type de données plus
général que l’on appelle des données composites
Exemple :
>>> ch = "Christine"
>>> print(ch[0], ch[3], ch[5])
Cit

2.2 Opérations élémentaires sur les chaînes

Python intègre de nombreuses fonctions qui permettent d’effectuer divers

traitements sur les chaines de caractères (conversions majuscules/minuscules,
découpage en chaines plus petites, recherche de mots, etc.).

• assembler plusieurs petites chaines pour en construire de plus grandes. Cette

opération s’appelle concaténation et on la réalise sous Python à l’aide de l’operateur
+ (cet opérateur réalise donc l’opération d’addition lorsqu’on l’applique à des
nombres, et l’opération de concaténation lorsqu’on l’applique à des chaines de
caractères).
Exemple :
a = 'Petit poisson'
b = ' deviendra grand'
c=a+b
print(c)
petit poisson deviendra grand

P a g e 7 | 28
• déterminer la longueur (c’est-à-dire le nombre de caractères) d’une chaine, en
faisant appel à la fonction intégrée len() :
>>> ch ='Georges'
>>> print(len(ch))
7
Cela marche tout aussi bien si la chaine contient des caractères accentues :
>>> ch ='Rene'
>>> print(len(ch))
4
• Convertir en nombre véritable une chaine de caractères qui représente un nombre.
Exemple :
>>> ch = '8647'
>>> print(ch + 45)
→ *** erreur *** : on ne peut pas additionner une chaine et un nombre
>>> n = int(ch)
>>> print(n + 65)
8712 # OK : on peut additionner 2 nombres
Dans cet exemple, la fonction intégrée int() convertit la chaine en nombre entier. Il
serait également possible de convertir une chaine de caractères en nombre réel, à
l’aide de la fonction intégrée float().

2.3 Les listes (première approche)

Les chaines que nous avons abordées à la rubrique précédente constituaient un
premier exemple de données composites. On appelle ainsi les structures de données
qui sont utilisées pour regrouper de manière structurée des ensembles de valeurs.
Vous apprendrez progressivement à utiliser plusieurs autres types de données
composites, parmi lesquelles les listes, les tuples et les dictionnaires.

Sous Python, on peut définir une liste comme une collection d’éléments séparés par
des virgules, l’ensemble étant enfermé dans des crochets. Exemple :
>>> jour = ['lundi', 'mardi', 'mercredi', 1800, 20.357, 'jeudi', 'vendredi']
>>> print(jour)
['lundi', 'mardi', 'mercredi', 1800, 20.357, 'jeudi', 'vendredi']
Dans cet exemple, la valeur de la variable jour est une liste.

Les divers éléments qui constituent une liste sont en effet toujours disposés dans le
même ordre, et l’on peut donc accéder a chacun d’entre eux individuellement si l’on
connait son index dans la liste.

P a g e 8 | 28
Exemples :
>>> jour = ['lundi', 'mardi', 'mercredi', 1800, 20.357, 'jeudi', 'vendredi']
>>> print(jour[2])
mercredi
>>> print(jour[4])
20.357
On peut donc remplacer certains éléments d’une liste par d’autres, comme ci-
dessous :
>>> jour[3] = 'Juillet'
>>> print(jour)
['lundi', 'mardi', 'mercredi', 'Juillet', 20.357, 'jeudi', 'vendredi']
La fonction intégrée len(), que nous avons déjà rencontré à propos des chaines,
s’applique aussi aux listes. Elle renvoie le nombre d’éléments présents dans la liste
:
>>> print(len(jour))
7
Une autre fonction intégrée permet de supprimer d’une liste un élément quelconque
(à partir de son index). Il s’agit de la fonction del() 23 :
>>> del(jour[4])
>>> print(jour)
['lundi', 'mardi', 'mercredi', 'juillet', 'jeudi', 'vendredi']
Il est également tout à fait possible d’ajouter un élément à une liste, mais pour ce
faire, il faut considérer que la liste est un objet, dont on va utiliser l’une des
méthodes. Les concepts informatiques d’objet et de méthode ne seront expliqués
qu’un peu plus loin dans ces notes, mais nous pouvons des à présent montrer ≪
comment ça marche ≫ dans le cas particulier d’une liste :
>>> [Link]('samedi')
>>> print(jour)
['lundi', 'mardi', 'mercredi', 'juillet', 'jeudi', 'vendredi', 'samedi']
>>>
Dans la première ligne de l’exemple ci-dessus, nous avons applique la méthode
append() a l’objet jour, avec l’argument ’samedi’. Si l’on se rappelle que le mot ≪
append ≫ signifie ≪ ajouter ≫

P a g e 9 | 28
en anglais, on peut comprendre que la méthode append() est une sorte de fonction
qui est en quelque manière attachée ou intégrée aux objets du type ≪ liste ≫.
L’argument que l’on utilise avec cette fonction est bien entendu l’élément que l’on
veut ajouter à la fin de la liste.

CHAP3 Fonctions prédéfinies

3.1 Interaction avec l’utilisateur : la fonction input()

La plupart des scripts élabores nécessitent a un moment ou l’autre une intervention
de l’utilisateur (entrée d’un paramètre, clic de souris sur un bouton, etc.). Dans un
script en mode texte (comme ceux que nous avons créés jusqu’à présent), la
méthode la plus simple consiste a employer la fonction intégrée input().
On peut invoquer la fonction input() en laissant les parenthèses vides. On peut aussi
y placer en argument un message explicatif destine à l’utilisateur.
Exemple :
prenom = input("Entrez votre prenom : ")
print("Bonjour,", prenom)

ou encore :
print("Veuillez entrer un nombre positif quelconque : ", end=" ")
ch = input()
nn = int(ch) # conversion de la chaîne en un nombre entier
print("Le carre de", nn, "vaut", nn**2)

3.2 Importer un module de fonctions

Les modules sont des fichiers qui regroupent des ensembles de fonctions
Le module math, par exemple, contient les définitions de nombreuses fonctions
mathématiques telles que sinus, cosinus, tangente, racine carrée, etc. Pour pouvoir
utiliser ces fonctions, il vous suffit d’incorporer la ligne suivante au début de votre
script :
from math import *

P a g e 10 | 28
Cette ligne indique a Python qu’il lui faut inclure dans le programme courant toutes
les fonctions (c’est là la signification du symbole ≪ joker ≫ *) du module math,
lequel contient une bibliothèque de fonctions mathématiques préprogrammées.
Dans le corps du script lui-même, vous écrirez par exemple :
racine = sqrt(nombre) pour assigner à la variable racine la racine carrée de nombre,
sinusx = sin(angle) pour assigner à la variable sinusx le sinus de angle (en radians
!), etc.
Exemple :
# Demo : utilisation des fonctions du module <math>
from math import *
nombre = 121
angle = pi/6 # soit 30°
# (la bibliothèque math inclut aussi la définition de pi)
print("racine carrée de", nombre, "=", sqrt(nombre))
print("sinus de", angle, "radians", "=", sin(angle))
L’exécution de ce script provoque l’affichage suivant :
racine carrée de 121 = 11.0
sinus de 0.523598775598 radians = 0.5

3.3 Le module turtle

L’une des grandes qualités de Python est qu’il est extrêmement facile de lui ajouter
de nombreuses fonctionnalités par importation de divers modules.
Pour illustrer cela, et nous amuser un peu avec d’autres objets que des nombres,
nous allons explorer un module Python qui permet de réaliser des ≪ graphiques
tortue ≫, c’est-à-dire des dessins géométriques correspondant à la piste laissée
derrière elle par une petite ≪ tortue ≫ virtuelle, dont nous contrôlons les
déplacements sur l’écran de l’ordinateur à l’aide d’instructions simples.
Les principales fonctions mises à votre disposition dans le module turtle sont les
suivantes :
reset() On efface tout et on recommence
goto(x, y) Aller à l’endroit de coordonnées x, y
forward(distance) Avancer d’une distance donnée
P a g e 11 | 28
backward(distance) Reculer
up() Relever le crayon (pour pouvoir avancer sans dessiner)
down() Abaisser le crayon (pour recommencer à dessiner)
color(couleur) couleur peut être une chaine prédéfinie (’red’, ’blue’, etc.)
left(angle) Tourner à gauche d’un angle donne (exprime en degrés)
right(angle) Tourner à droite
width(epaisseur) Choisir l’épaisseur du trace
fill(1) Remplir un contour ferme à l’aide de la couleur sélectionnée
write(texte) texte doit être une chaine de caractères

Exemple : Le programme suivant dessine un rectangle

import turtle
# Créer une fenêtre
fenetre = [Link]()
[Link]("Mon rectangle")
# Créer une tortue
tortue = [Link]()
# Définir les dimensions du rectangle
longueur = 100
largeur = 50
# Dessiner le rectangle
for _ in range(2):
[Link](longueur)
[Link](90)
[Link](largeur)
[Link](90)
# Maintenir la fenêtre ouverte
[Link]()

CHAP4 Les structures de contrôle

Elles permettent de contrôler le flux d'exécution d'un programme :

P a g e 12 | 28
 4.1 Les conditions

Code Python

if condition:
# Code à exécuter si la condition est vraie
else:
# Code à exécuter si la condition est fausse

4.2 Les boucles

4.2.1 Qu'est-ce qu'une boucle for ?

En Python, la boucle for est un outil fondamental pour itérer sur une séquence
d'éléments. Cela signifie qu'elle permet d'exécuter un bloc d'instructions de manière
répétée pour chaque élément de cette séquence. Cette séquence peut être une liste,
un tuple, une chaîne de caractères, un dictionnaire, ou tout autre objet itérable.

4.2.2 Syntaxe de base :

Code Python
for élément in séquence:
# Instructions à exécuter pour chaque élément

 élément: Une variable qui prendra successivement la valeur de chaque

élément de la séquence lors de chaque itération.
 séquence: La collection d'éléments sur laquelle on souhaite itérer (liste,
tuple, chaîne, etc.).

4.2.3 Exemples d'utilisation :

[Link] Itérer sur une liste :

Code Python
fruits = ["pomme", "banane", "cerise"]
for fruit in fruits:
print(fruit)

Ce code affichera :

Pomme

banane

cerise

P a g e 13 | 28
[Link] Itérer sur une chaîne de caractères :
Code Python
mot = "Python"
for lettre in mot:
print(lettre)
Ce code affichera chaque lettre du mot "Python" sur une ligne séparée.

[Link] Itérer sur un dictionnaire :

Code Python
personne = {"nom": "Dupont", "age": 30, "ville": "Paris"}
for clé in personne:
print(clé, personne[clé])

Ce code affichera les clés et les valeurs du dictionnaire :

nom Dupont
age 30
ville Paris

[Link] Utilisations avancées :

 range(): Pour générer une séquence de nombres :

Python

for i in range(5):
print(i) # Affichera les nombres de 0 à 4

 enumerate(): Pour obtenir l'index et la valeur de chaque élément :

Python

for i, fruit in enumerate(fruits):

print(i, fruit)

 break: Pour sortir prématurément de la boucle :

Python

for i in range(10):
if i == 5:
break

P a g e 14 | 28
 print(i)

 continue: Pour passer à l'itération suivante :

Python

for i in range(10):
if i % 2 == 0:
continue # Passe aux nombres impairs
print(i)

4.3 Boucle while

Exécute un bloc de code tant qu'une condition est vraie

4.3.1 Qu'est-ce qu'une boucle while ?

La boucle while en Python est un autre outil fondamental pour la répétition d'un bloc
d'instructions. Contrairement à la boucle for qui itère sur une séquence connue à
l'avance, la boucle while continue d'exécuter le bloc tant qu'une condition donnée
reste vraie.

4.3.2 Syntaxe de base :

Code Python
while condition:
# Instructions à exécuter tant que la condition est vraie

 condition: Une expression booléenne (qui renvoie True ou False).

 Instructions: Le bloc de code qui sera exécuté à chaque itération tant que la
condition est vérifiée.

Exemple :

Python
compte = 0
while compte < 5:
print(compte)
compte = compte + 1

Ce code affichera les nombres de 0 à 4. La boucle continue tant que la variable

compte est strictement inférieure à 5.

P a g e 15 | 28
4.3.3 Quand utiliser while plutôt que for ?

 Nombre d'itérations inconnu: Lorsque vous ne savez pas à l'avance combien

de fois vous devez répéter un bloc d'instructions.
 Conditions complexes: Lorsque la condition d'arrêt dépend de plusieurs
facteurs ou de calculs plus élaborés.
 Boucles infinies (potentielles): Si la condition n'est jamais fausse, la boucle
continuera indéfiniment. Il est donc important de s'assurer qu'il existe un
moyen de sortir de la boucle.

4.3.4 Exemples d'utilisation :

 Saisie utilisateur:

Code Python

mot_de_passe = ""
while mot_de_passe != "secret":
mot_de_passe = input("Entrez le mot de passe : ")
print("Accès autorisé")

 Calculs itératifs:

Code Python

nombre = 10
while nombre > 0:
print(nombre)
nombre -= 1

 Simulations:

Code Python

import random

nombre_aleatoire = [Link](1, 10)

trouve = False
while not trouve:
guess = int(input("Devinez un nombre entre 1 et 10 : "))
if guess == nombre_aleatoire:
print("Félicitations, vous avez gagné !")
trouve = True
elif guess < nombre_aleatoire:
print("Trop petit")
else:
print("Trop grand")
P a g e 16 | 28
 CHAP 5 Fonctions originales
5.1 Définition

Elles permettent de regrouper un ensemble d'instructions pour effectuer une tâche

spécifique.

Les fonctions en Python sont des blocs de code organisés qui effectuent une tâche
spécifique. Elles permettent de :

 Structurer le code: En divisant un programme en fonctions plus petites, le

code devient plus lisible et plus facile à maintenir.
 Réutiliser du code: Une fois définie, une fonction peut être appelée à
plusieurs endroits dans le programme, évitant les répétitions.
 Créer des modules: Les fonctions peuvent être regroupées dans des modules
pour organiser le code de manière plus modulaire.

5.2 Syntaxe de base

def nom_de_la_fonction (paramètre1, paramètre2, ...):

"""Docstring de la fonction (description de ce qu'elle fait)"""

# Instructions de la fonction
return valeur_de_retour

 def: Mot-clé pour définir une fonction.

 nom_de_la_fonction: Nom choisi pour identifier la fonction.
 paramètre1, paramètre2, ...: Paramètres optionnels que la fonction peut
recevoir.
 docstring: Chaîne de caractères décrivant la fonction (facultative mais
fortement recommandé).
 return: Mot-clé pour retourner une valeur (facultatif).

5.3 Exemples
Exemple : Calculer le cube d’un nombre
>>> def cube(w):
... return w*w*w

Exemple : Calculer une aire

def aire_cercle(rayon):
"""Calcule l'aire d'un cercle.
Args:
rayon: Le rayon du cercle.
P a g e 17 | 28
 Returns:
L'aire du cercle.
"""
import math
return [Link] * rayon**2

# Appel de la fonction
resultat = aire_cercle(5)
print (resultat)

5.4 Avantages des fonctions

 Modularité: Le code est plus facile à comprendre et à modifier.

 Réutilisabilité: Les fonctions peuvent être appelées plusieurs fois.
 Abstraction: On peut cacher la complexité de certaines opérations.
 Tests unitaires: Il est plus facile de tester des fonctions individuellement.

Les fonctions sont un élément fondamental de la programmation en Python. Elles

permettent d'organiser le code de manière efficace et de créer des programmes plus
robustes et maintenables.

CHAP6 Utilisation de fenêtres et de

Graphismes
6.1 Interfaces graphiques (GUI)
Si vous ne le saviez pas encore, apprenez des à présent que le domaine des interfaces
graphiques (ou GUI : Graphical User Interfaces) est extrêmement complexe.
Tous ces composants sont généralement présents comme des classes d’objets, dont
il vous faudra étudier les attributs et les méthodes.

Avec Python, la bibliothèque graphique la plus utilisée jusqu’à présent est la

bibliothèque tkinter, qui est une adaptation de la bibliothèque Tk développée à
l’origine pour le langage Tcl.
Plusieurs autres bibliothèques graphiques fortes intéressantes ont été proposées pour
Python : wxPython, pyQT, pyGTK, etc. Il existe également des possibilités d’utiliser
les bibliothèques de widgets Java et les MFC de Windows. Dans le cadre de ces notes,
nous nous limiterons cependant à tkinter, dont il existe fort heureusement des
versions similaires (et gratuites) pour les plates-formes Linux, Windows et Mac OS.

P a g e 18 | 28
6.2 Premiers pas avec tkinter

Pour pouvoir en utiliser les fonctionnalités dans un script

Python, il faut que l’une des premières lignes de ce script contienne l’instruction
d’importation
:
from tkinter import *
Dans l’exemple qui suit, nous allons créer une fenêtre très simple, et y ajouter deux
widgets typiques : un bout de texte (ou label) et un bouton (ou button).
>>> from tkinter import *
>>> fen1 = Tk()
>>> tex1 = Label(fen1, text='Bonjour tout le monde !', fg='red')
>>> [Link]()
>>> bou1 = Button(fen1, text='Quitter', command = [Link])
>>> [Link]()
>>> [Link]()

Le programme suivant créer un formulaire simple avec des champs pour le nom
et le prénom :
import tkinter as tk

# Créer la fenêtre principale

fenetre = [Link]()
[Link]("Formulaire Nom et Prénom")

# Créer les labels pour les champs

label_nom = [Link](fenetre, text="Nom :")
label_prenom = [Link](fenetre, text="Prénom :")

# Créer les champs d'entrée

entree_nom = [Link](fenetre)
entree_prenom = [Link](fenetre)

# Positionner les éléments sur la fenêtre

label_nom.pack()
entree_nom.pack()
label_prenom.pack()
entree_prenom.pack()

P a g e 19 | 28
# Fonction pour récupérer les données saisies
def recuperer_donnees():
nom = entree_nom.get()
prenom = entree_prenom.get()
print("Nom :", nom)
print("Prénom :", prenom)

# Créer un bouton pour récupérer les données

bouton = [Link](fenetre, text="Valider", command=recuperer_donnees)
[Link]()

# Lancer la boucle principale de l'application

[Link]()

CHAP7 Approfondir les structures de Données

7.1 Le point sur les chaînes de caractères
En fait, les chaines de caractères font partie d’une catégorie d’objets Python que
l’on appelle des séquences, et dont font partie aussi les listes et les tuples. On
peut effectuer sur les séquences tout un ensemble d’Operations similaires.

7.1.1 Indiçage, extraction, longueur

Pour extraire un caractère d’une chaine, il suffit d’accoler au nom de la variable qui
contient cette chaine, son indice entre crochets :

>>> nom = 'Cedric'

>>> print(nom[1], nom[3], nom[5])
erc

Il est souvent utile de pouvoir designer l’emplacement d’un caractère par rapport à
la fin de la chaine. Pour ce faire, il suffit d’utiliser des indices négatifs : ainsi -1
désignera le dernier caractère,
-2 l’avant-dernier, etc. :
>>> print(nom[-1], nom[-2], nom[-4], nom[-6])
cidC
>>>
P a g e 20 | 28
Si l’on désire déterminer le nombre de caractères présents dans une chaine, on
utilise la fonction intégrée len() :
>>> print(len(nom))
6

7.1.2 Extraction de fragments de chaînes

Il arrive fréquemment, lorsque l’on travaille avec des chaines, que l’on souhaite
extraire une petite chaine d’une chaine plus longue. Python propose pour cela une
technique simple que l’on appelle slicing (≪ découpage en tranches ≫). Elle consiste
à indiquer entre crochets les indices correspondant au début et à la fin de la ≪
tranche ≫ que l’on souhaite extraire :
>>> ch = "Juliette"
>>> print(ch[0:3])
Jul

Dans la tranche [n,m], le nième caractère est inclus, mais pas le miéme.

7.1.3 Accéder à d’autres caractères que ceux du clavier

La fonction ord(ch) accepte n’importe quel caractère comme argument. En retour,
elle fournit la valeur de l’identifiant numérique correspondant à ce caractère. Ainsi
ord("A") renvoie la valeur 65,
La fonction chr(num) fait exactement le contraire, en vous présentant le caractère
typographique dont l’identifiant Unicode est égal a num
Ainsi, par exemple, chr(65) renvoie le caractère A,

7.1.4 Création d’une liste de nombres à l’aide de la fonction range()

Elle renvoie une séquence d’entiers67 que vous pouvez utiliser
directement, ou convertir en une liste avec la fonction list(), ou convertir en tuple
avec la fonction tuple() (les tuples seront décrits un peu plus loin) :
>>> list(range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

La fonction range() génère par défaut une séquence de nombres entiers de valeurs
croissantes, et différant d’une unité. Si vous appelez range() avec un seul argument,
P a g e 21 | 28
la liste contiendra un nombre de valeurs égal a l’argument fourni, mais en
commençant à partir de zéro (c’est-à-dire que range(n) génère les nombres de 0 à
n-1).
Notez bien que l’argument fourni n’est jamais dans la liste générée.
On peut aussi utiliser range() avec deux, ou même trois arguments sépares par des
virgules, afin de générer des séquences de nombres plus spécifiques :
>>> list(range(5,13))
[5, 6, 7, 8, 9, 10, 11, 12]
>>> list(range(3,16,3))
[3, 6, 9, 12, 15]

Si vous avez du mal à assimiler l’exemple ci-dessus, considérez que range() attend
toujours de un à trois arguments, que l’on pourrait intituler FROM, TO et STEP. FROM
est la première valeur à générer, TO est la dernière (ou plutôt la dernière + un), et
STEP le ≪ pas ≫ à sauter pour passer d’une valeur à la suivante. S’ils ne sont pas
fournis, les paramètres FROM et STEP prennent leurs valeurs par défaut, qui sont
respectivement 0 et 1.
Les arguments négatifs sont autorisés :
>>> list(range(10, -10, -3))
[10, 7, 4, 1, -2, -5, -8]

7.1.5 Test d’appartenance

Vous pouvez aisément déterminer si un élément fait partie d’une liste à l’aide de
l’instruction in (cette instruction puissante peut être utilisée avec toutes les
séquences) :
>>> v = 'tomate'
>>> if v in legumes:
... print('OK')
...

7.2 Les dictionnaires

Ils ressemblent aux listes dans une certaine mesure (ils sont modifiables comme
elles), mais ce ne sont pas des séquences.

P a g e 22 | 28
7.2.1 Création d’un dictionnaire
A titre d’exemple, nous allons créer un dictionnaire de langue, pour la traduction de
termes informatiques anglais en français.
Puisque le type dictionnaire est un type modifiable, nous pouvons commencer par
créer un dictionnaire vide, puis le remplir petit à petit. Du point de vue de la syntaxe,
on reconnait un dictionnaire au fait que ses éléments sont enfermes dans une paire
d’accolades. Un dictionnaire
vide sera donc note { } :
>>> dico = {}
>>> dico['computer'] = 'ordinateur'
>>> dico['mouse'] ='souris'
>>> dico['keyboard'] ='clavier'
>>> print(dico)
{'computer': 'ordinateur', 'keyboard': 'clavier', 'mouse': 'souris'}

7.2.2 Opérations sur les dictionnaires

Vous savez déjà comment ajouter des éléments a un dictionnaire. Pour en enlever,
vous utiliserez l’instruction intégrée del.
>>> invent = {'pommes': 430, 'bananes': 312, 'oranges' : 274, 'poires' : 137}
>>> print(invent)
{'oranges': 274, 'pommes': 430, 'bananes': 312, 'poires': 137}
Si le patron décide de liquider toutes les pommes et de ne plus en vendre, nous
pouvons enlever cette entrée dans le dictionnaire :
>>> del invent['pommes']
>>> print(invent)
{'oranges': 274, 'bananes': 312, 'poires': 137}
La fonction intégrée len() est utilisable avec un dictionnaire : elle en renvoie le
nombre d’éléments :
>>> print(len(invent))
3
7.2.3Test d’appartenance
Elle permet de savoir si un dictionnaire comprend une clé bien déterminée :
>>> if "pommes" in invent:
... print("Nous avons des pommes")

P a g e 23 | 28
... else:
... print("Pas de pommes. Sorry")
...
Pas de pommes. Sorry

7.2.4 Parcours d’un dictionnaire

Vous pouvez utiliser une boucle for pour traiter successivement tous les éléments
contenus dans un dictionnaire, mais attention :
• au cours de l’itération, ce sont les clés utilisées dans le dictionnaire qui seront
successivement affectées a la variable de travail, et non les valeurs ;
• l’ordre dans lequel les éléments seront extraits est imprévisible (puisqu’un
dictionnaire n’est pas une séquence).
Exemple :
>>> invent ={"oranges":274, "poires":137, "bananes":312}
>>> for clef in invent:
... print(clef)
...
poires
bananes
oranges

7.2.5 Les clés ne sont pas nécessairement des chaînes de caractères

Considérons par exemple que nous voulions répertorier les arbres remarquables
situes dans un grand terrain rectangulaire. Nous pouvons pour cela utiliser un
dictionnaire, dont les clés seront des tuples indiquant les coordonnées x,y de chaque
arbre :
>>> arb = {}
>>> arb[(1,2)] = 'Peuplier'
>>> arb[(3,4)] = 'Platane'
>>> arb[6,5] = 'Palmier'
>>> arb[5,1] = 'Cycas'
>>> arb[7,3] = 'Sapin'
>>> print(arb)
{(3, 4): 'Platane', (6, 5): 'Palmier', (5, 1):
'Cycas', (1, 2): 'Peuplier', (7, 3): 'Sapin'}
P a g e 24 | 28
>>> print(arb[(6,5)])
Palmier

CHAP8 Les frameworks web Python

Les frameworks web Python offrent une structure et des outils pour développer des
applications web de manière plus rapide et efficace. Ils fournissent des
fonctionnalités prêtes à l'emploi, telles que la gestion des requêtes HTTP, la
génération de templates, la gestion de bases de données, etc.

8.1 Pourquoi utiliser un framework ?

 Productivité: Accès à des fonctionnalités déjà implémentées, ce qui réduit le temps

de développement.
 Structure: Organisation du code, facilitant la maintenance et la collaboration.
 Sécurité: Intégration de mécanismes de sécurité pour protéger les applications.
 Communauté: Grande communauté d'utilisateurs, offrant une abondance de
ressources et de support.

8.2 Les principaux frameworks web Python

Voici une présentation des frameworks les plus populaires, classés en deux catégories
:

8.2.1 Frameworks complets (full-stack)

Ces frameworks offrent un ensemble complet d'outils pour développer des

applications web complexes.

 Django:
o Description: Le framework le plus populaire et complet, idéal pour des
projets de grande envergure. Il suit le modèle MVC (Modèle-Vue-Contrôleur).
o Caractéristiques: ORM puissant, système de templates flexible,
administration intuitive, communauté active.

P a g e 25 | 28
  Pyramid:
o Description: Framework modulaire et flexible, offrant un bon compromis
entre simplicité et fonctionnalités.
o Caractéristiques: Grande personnalisation, performances élevées, adapté à
des projets de taille variable.

 TurboGears:
o Description: Framework combinant les meilleures caractéristiques de
plusieurs autres, offrant une grande flexibilité.
o Caractéristiques: Très personnalisable, intégration de technologies
modernes.

8.2.2 Micro-frameworks

Ces frameworks sont plus légers et offrent un contrôle plus fin sur le développement.
Ils sont parfaits pour de petits projets ou des API.

 Flask:
o Description: Micro-framework minimaliste et flexible, souvent utilisé comme
point de départ pour des projets personnalisés.
o Caractéristiques: Facile à apprendre, extensible, adapté à des projets de
petite et moyenne taille.

P a g e 26 | 28
  Bottle:
o Description: Micro-framework ultraléger, idéal pour de très petites
applications ou des API REST.
o Caractéristiques: Extrêmement simple, parfait pour apprendre les bases du
développement web avec Python.

 FastAPI:
o Description: Micro-framework moderne, axé sur la performance et la facilité
de développement, notamment pour les API.
o Caractéristiques: Très rapide, basé sur des standards ouverts, type hinting.

8.3 Comment choisir le bon framework ?

Le choix du framework dépend de plusieurs facteurs :

 Taille du projet: Pour de grands projets, Django est un excellent choix. Pour de
petits projets, Flask ou Bottle peuvent suffire.
 Complexité: Si vous avez besoin de fonctionnalités avancées, un framework complet
comme Django ou Pyramid est plus adapté.
 Expérience: Si vous débutez, Flask est souvent recommandé pour sa simplicité.

P a g e 27 | 28
 Performances: Pour des applications nécessitant des performances élevées, FastAPI
est un bon choix.

« le monde offre ses faveurs aux esprits éveillés »

P a g e 28 | 28