Les bases de la

programmation Python

Dr N. BAME
 Les variables
• Les noms de variables doivent 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, à
l’exception du caractère _ (souligné).

• Les mots réservés de Python :

• La casse est significative : les caractères majuscules et minuscules sont distingués

• En Python, la déclaration d’une variable et son initialisation se font en même temps.

x = 2
 Types de données
• Les principaux types en Python sont :
• Les entiers ;
• les réels ou flottants ;
• les chaînes de caractères ;
• les listes ;
• les dictionaires.

• Python est un langage au typage dynamique

• La fonction type()
• Permet de connaître le type d’une variable (ou d’une expression).
 Les variables : types et les opérations
• Affectations multiples
• on peut assigner une valeur à plusieurs variables simultanément
• x=y=7
• On peut aussi effectuer des affectations parallèles à l’aide d’un seul opérateur :
• a, b = 4, 8.33

• Les opérateurs Python ne sont pas seulement les quatre opérateurs

mathématiques de base.
• Opérateur de division entière //.
• Opérateur ** pour l’exponentiation,
r , pi = 12, 3.14159
s = pi * r**2
print(s)
 Opérations sur les chaînes de caractères
• Pour les chaînes de caractères, deux opérations sont possibles, l’addition
(concaténation) et la multiplication :
• L’opérateur d’addition + concatène deux chaînes de caractères.
• L’opérateur de multiplication * entre un nombre entier et une chaîne de caractères
duplique (répète) plusieurs fois une chaîne

1 >>> chaine = " Salut "

2 >>> chaine
3 'Salut '
4 >>> chaine + " Python "
5 'Salut Python '
6 >>> chaine * 3
7 ' SalutSalutSalut '
 Sémantique du langage
• La sémantique du langage Python se distingue par son accent sur la lisibilité, la simplicité et la clarté.
• Indentation, pas d'accolades
• Python utilise des espaces (tabulations ou espaces) pour structurer le code au lieu d'utiliser des accolades comme
dans de nombreux autres langages comme R, C ++, Java et Perl.
• Considérez une boucle for à partir d'un algorithme de tri:

• Un deux-points indique le début d'un bloc de code en retrait, après quoi tout le code doit être mis en
retrait du même montant jusqu'à la fin du bloc.
• Les espaces blancs importants sont une réalité pour les programmeurs Python, et cela peut rendre le
code Python plus lisible que d’autres langages.

• Comme vous pouvez le voir maintenant, les instructions Python n'ont pas non plus besoin d'être
terminées par des points-virgules.
• Cependant, des points-virgules peuvent être utilisés pour séparer plusieurs instructions sur une seule ligne:
a = 5; b = 6; c = 7
• Mettre plusieurs instructions sur une seule ligne est généralement déconseillé en Python car cela rend souvent le
code moins lisible.
 Sémantique du langage
• Tout est objet
• Une caractéristique importante du langage Python est la cohérence de son modèle objet.
• Chaque nombre, chaîne, structure de données, fonction, classe, module, etc. existe dans l'interpréteur Python
dans sa propre «boîte», appelée objet Python.
• Chaque objet a un type associé (par exemple, une chaîne ou une fonction) et des données internes.
• En pratique, cela rend le langage très flexible, car même les fonctions peuvent être traitées comme n'importe
quel autre objet.
• Commentaires
• Tout texte précédé du signe dièse # est ignoré par l'interpréteur Python. Ceci est souvent utilisé
pour ajouter des commentaires au code.
• Parfois, vous pouvez également vouloir exclure certains blocs de code sans les supprimer. Une solution simple
consiste à commenter le code:

• Les commentaires peuvent également apparaître après une ligne de code exécuté. Alors que
certains programmeurs préfèrent que les commentaires soient placés dans la ligne précédant une
ligne de code particulière, cela peut parfois être utile:
 Sémantique du langage
Utilisation de fonction et de méthode
• Vous appelez des fonctions en utilisant des parenthèses et en passant zéro ou
plusieurs arguments, en affectant éventuellement la valeur renvoyée à une
variable:
result = f( x, y, z )
g()

• Presque tous les objets en Python ont des fonctions attachées, appelées
méthodes, qui ont accès au contenu interne de l'objet.
• Vous pouvez les appeler en utilisant la syntaxe suivante:
obj.some_method(x, y, z)

• Les fonctions peuvent prendre à la fois des arguments positionnels et des mots-
clés:
result = f(a, b, c, d=5, e='foo')
 Fonctions de lecture et d’affichage
• print()
• Permet d’afficher n’importe quel nombre de valeurs fournies en arguments
• Par défaut, ces valeurs seront séparées les unes des autres par un espace, et le tout se terminera par un
saut à la ligne.
• Vous pouvez remplacer le séparateur par défaut (l’espace) par un autre caractère quelconque, grâce à
l’argument sep.
print("Bonjour", "à", "tous", sep ="*")
Bonjour*à*tous
print("Bonjour", "à", "tous", sep ="")
Bonjouràtous

• De même, on peut remplacer le saut à la ligne par l’argument end :

n =0
while n<6:
print("zut", end ="")
n = n+1

zutzutzutzutzut
 Fonctions de lecture et d’affichage
• Écriture formatée
• La méthode .format() permet une meilleure organisation de l’affichage des variables
x = 32
nom = "John"
print ("{} a {} ans". format(nom , x))
# John a 32 ans

• Dans la chaîne de caractères, les accolades vides {} précisent l’endroit où le contenu de la variable doit être inséré.
• Juste après la chaîne de caractères, l’instruction .format(nom, x) fournit la liste des variables à insérer, d’abord la
variable nom puis la variable x.
• La méthode .format() agit sur la chaîne de caractères à laquelle elle est attachée parle point.

• Dans le cas présent, vous voulez formater un float pour l’afficher avec deux puis trois décimales :
prop_GC = (4500 + 2575) / 14800
print("La proportion de GC est {:.2f}". format(prop_GC ))
Le proportion de GC est 0.48
print("La proportion de GC est {:.3f}". format(prop_GC ))
La proportion de GC est 0.478

• Détaillons le contenu des accolades de la première ligne ({:.2f}) :

• Les deux points : indiquent qu’on veut préciser le format.
• La lettre f indique qu’on souhaite afficher la variable sous forme d’un float.
• Les caractères .2 indiquent la précision voulue, soit ici deux chiffres après la virgule
 Fonctions de lecture et d’affichage
• Écriture scientifique
• Pour les nombres très grands ou très petits, l’écriture formatée permet d’afficher un
nombre en notation scientifique (sous forme de puissance de 10) avec la lettree:

print ("{:e}". format (1 000000000 ))

1.000000e+09
print ("{:e}". format (0.000 000001 ))
1.000000e-09

• Il est également possible de définir le nombre de chiffres après la virgule.

• Dans l’exemple ci-dessous, on affiche un nombre avec aucun, 3 et 6 chiffres après la virgule:
avogadro_number = 6.022 _140_76e+23
print ("{:.0e}". format(avogadro_number ))
6e+23
print ("{:.3e}". format(avogadro_number ))
6.022e+23
print ("{:.6e}". format(avogadro_number ))
6.022141e+23
 Fonctions de lecture et d’affichage
input()
• L’utilisateur est invité à entrer des caractères au clavier et à terminer avec <Enter>.
prenom = input("Entrez votre prénom : ")
print("Bonjour,", prenom)

print("Veuillez entrer un nombre positif quelconque : ", end=" ")

ch = input()
nn = int(ch) # conversion de la chaîne en un nombre entier
print("Le carré de", nn, "vaut", nn**2)

• Soulignons que la fonction input() renvoie toujours une chaîne de caractères

 Exercice
• Créer deux variables à initialiser par l’utilisateur avec des valeurs numériques
• Afficher les valeurs
• Afficher dans un message personnalisé
• Calculer et afficher les somme et produit des deux variables avec l’affectation
multiple
• Formater l’affichage dans un message personnalisé

• Puissance xn avec des valeurs saisies par l’utilisateur.

• Chaînes de caractères
• Lecture, opération, concaténation et affichage: nom, prénom et age
• Réplication : Hello!Hello!Hello!
Structures de contrôle
 Instructions composées – blocs d’instructions
• Sous Python, les instructions composées ont toujours la même structure :
• une ligne d’en-tête terminée par un double point,
• suivie d’une ou de plusieurs instructions indentées sous cette ligne d’en-tête.
• Exemple :
Ligne d’en-tête :
première instruction du bloc
... ...
... ...
dernière instruction du bloc
• S’il y a plusieurs instructions indentées sous la ligne d’en-tête, elles doivent l’être exactement
au même niveau.
a=7
if (a % 2 == 0):
print("a est pair")
print("parce que le reste de sa division par 2 est nul")
else:
print("a est impair")
 Instructions imbriquées
• Il est parfaitement possible d’imbriquer les unes
dans les autres plusieurs instructions composées,
de manière à réaliser des structures de décision
complexes.

• Les limites des instructions et des blocs sont

définies par la mise en page

• Instruction composée : en-tête, double point,

bloc d’instructions indenté
 Structures de contrôle
• if : syntaxe
if <condition 1> :
<traitement 1>
[
elif <condition 2> :
<traitement 2>
elif <condition 3> :
<traitement 3> n = input("Entrer un nombre : ")
... if n % 2 == 0:
elif <condition n> : print("pair")
<traitement n> else:
] print("impair")
[
else :
<traitement else>
]
 Structures de contrôle
• for
for i in range(10):
for x in <iterable>: print(i)
<traitement for>
C’est une boucle « for » qui fait 10 itérations. la variable « i » prend les
valeurs de 0 à 9.
• while
while <condition>: a=0
<traitement while> while a < 10:
print(a)
a=a+1
 Exercice
Exercice 1.
Ecrivez un programme qui calcule et affiche le minimum et le maximum entre quatre nombres entiers
saisis par l’utilisateur.
Exercice 2.
Ecrire un programme appelé Minimum pour calculer le minimum des entiers positifs donnés par
l’utilisateur. La boucle se termine quand l’utilisateur donne un nombre négatif. Le minimum calculé est
affiché par la suite.

Exercice 3.
Ecrire un programme qui demande à l’utilisateur de donner deux entiers strictement positifs, puis calcule
la somme des nombres pairs compris entre ces deux entiers (inclus). Le résultat calculé est affiché après.

Exercice 4.
Ecrire un programme qui demande un nombre de départ, et qui ensuite affiche les dix nombres suivants
avec leurs carrés. Par exemple, si l'utilisateur entre le nombre 17, le programme affichera les nombres de
18 à 27 avec leurs carrés.
L’utilisateur doit pouvoir recommencer plusieurs fois s’il le désire : le nombre de répétitions est limité à
10.
 Exercice
1. Ecrire un script auquel on fournit un rang entier n, et qui calcule et affiche la valeur
au rang n des suites suivantes :

2. Ecrire un script qui demande à l’utilisateur de saisir un nombre entier strictement

positif, puis, calcule et affiche la somme et le produit des chiffres qui composent le
nombre entier saisi ; le nombre de chiffres de l’entier saisi n’est pas connu a priori.

3. La population des Sims Alpha est initialement du nombre des deux tiers de celle des
Sims Beta. Elle augmente de 3% par an et celle des Sims Beta augmente
annuellement de façon constante de 3% de sa population initiale.
• Ecrire un algorithme qui demande la population initiale des Sims Alpha (qui doit être entre 10000 et
60000) et détermine et affiche dans combien d’années la population des Sims Alpha dépassera celle
des Sims Beta.
 Les fonctions
• En Python, une fonction est un objet qui doit être déclaré.
• Syntaxe :
def nomDeLaFonction( [arg1, arg2,…,argN] ) :
bloc d’instructions

• Retour de résultat
• La fonction peut contenir une instruction de la forme : return expression.
• Exemple def carre(x) :
ca = x*x
return ca

a=128
b=carre(a)
print(a, " au carré= ",b)
 Renvoi de résultats
• Un énorme avantage en Python est que les fonctions sont capables de renvoyer plusieurs
objets à la fois
def carre_cube(x):
return x**2, x**3

carre_cube(2)
(4, 8)
• En réalité Python ne renvoie qu'un seul objet, mais celui-ci peut contenir lui même
d'autres objets.
• Dans l’exemple Python renvoie un objet de type tuple,
• Une fonction pourrait tout autant renvoyer une liste :
def carre_cube2(x):
return [x**2 , x**3]

carre_cube2(3)
[9, 27]
• Renvoyer un tuple ou une liste de deux éléments (ou plus) est très pratique en conjonction avec
l'affectation multiple, par exemple :
z1, z2 = carre_cube2(3)
z1 9
z2 27
 Exercice
Définitions et utilisation des fonctions pour :
1. Afficher un message de bienvenue personnalisé ;
2. Afficher la table de multiplication du nombre passé en parameter;
3. Calculer et retourner la puissance xn en fonction des paramètres x et n;
4. Calculer la somme et le produit de deux nombres passes en parameter.

• Définir une fonction qui prend en paramètre un entier positif et renvoie VRAI
lorsque cet entier est parfait ou FAUX dans le cas contraire.
Ecrire un programme qui affiche qu’un nombre positif saisi par l’utilisateur est parfait ou non
en utilisant le sous-programme défini en 1°).
L’utilisateur doit pouvoir recommencer plusieurs fois s’il le désire.
Rappel : un nombre parfait est un nombre qui est égal à la somme de ses diviseurs. Par
exemple, 6 est parfait car les diviseurs de 6 sont : 1, 2 et 3 et que 1+2+3=6.
 Arguments positionnels et arguments par mot-clé
• Les arguments positionnels doivent toujours être placés avant les arguments par mot-clé
def fct( a, b, x=0, y=0, z=0 ):
return a, b, x, y, z

fct(1, 1) #(1, 1, 0, 0, 0)

fct(1, 1, z=5) #(1, 1, 0, 0, 5)

fct(1, 1, z=5, y=32 ) #(1, 1, 0, 32, 5)

• On peut toujours passer les arguments par mot-clé dans un ordre arbitraire à partir du
moment où on précise leur nom.
• Par contre, si les deux arguments positionnels a et b ne sont pas passés à la fonction, Python
renvoie une erreur.
• L'utilisation d'arguments par mot-clé en Python permet de modifier le comportement par
défaut de nombreuses fonctions.
• Par exemple, si on souhaite que la fonction print() n'affiche pas un retour à la ligne, on peut utiliser
l'argument end : print("Message ", end="")
Message
 Exercice
• Définition et utilisation des fonctions pour :
• Afficher la table de multiplication du nombre passé en paramètre avec une valeur
par défaut de 2
• Afficher un message de bienvenue personnalisé avec le nom et sexe par
défaut Mr.
• Fonction Puissance par défaut n=1.
 Les fonctions lambda
• Les fonctions lambda sont des fonctions qui ne sont pas définies avec un nom, mais qui peuvent être
utilisées dans des expressions ou des fonctions.
• Elles sont souvent utilisées dans des situations où une fonction simple est nécessaire pour une tâche
spécifique,
• comme trier une liste ou filtrer des éléments.
• En Python, le mot-clé lambda est utilisé pour définir des fonctions anonymes, également appelées
fonctions lambda.
• Syntaxe
lambda arguments : expression
• Les arguments sont les paramètres de la fonction et l'expression est le corps de la fonction.
• La fonction anonyme renvoie la valeur de l'expression évaluée comme n'importe quelle fonction
Python classique.
square = lambda x : x ** 2
square(2)
 Pourquoi utiliser des fonctions lambda ?
• Simplification du code
• Les fonctions lambda sont utiles pour écrire du code plus concis et lisible.

• Flexibilité :
• Les fonctions lambda peuvent être utilisées pour des tâches ponctuelles qui ne nécessitent pas
la création d'une fonction complète
• Programmation fonctionnelle :
• Les fonctions anonymes sont couramment utilisées en programmation fonctionnelle,
• où les fonctions sont traitées comme des valeurs et peuvent être utilisées pour effectuer des opérations
telles que le filtrage, le tri ou la transformation des données.
• Performance :
• Les fonctions lambda peuvent parfois offrir des performances supérieures à celles des fonctions définies
avec un nom, car elles sont compilées de manière dynamique au moment de leur utilisation, plutôt que
d'être définies et stockées en mémoire.
Exercice