10-12-2022

Formation en Python
Concept N°1 : les basiques de langage et code

Objectif de cette partie :

• Comprendre les concepts
proposés par Python.
• Découvrir les facilités
suggérées par python par
rapport aux autres langages
de programmation .
• Se familiariser avec le langage
Python.
• Résoudre des problématiques
Responsable de concept :
en utilisant Python. Bourakna mouaad
Club DSCC vous présente une
formation en python qui vous
permettra par la suite de réaliser
n’import quel projet que vous
pouvez réaliser avec C , en faisant
une simulation qui amène vers
une comparaison entre ces deux
dernier langages de
programmations. Dans ce qui suit
vous allez trouver une
comparaison entre les des
instruction au niveau syntaxique et
fonctionnel .
 I - Enivrement de développement et logiciel.

Généralement on peut utiliser deux type de d’environnement dont l’une des différences principales est au niveau
d’exécution la première exécute le code tout entier et la deuxième exécute le code partiellement c.-à-d. l’exécution
s’effectue par bloc .
PyCharm : est un environnement Jupyter Notebook: est une
de développement intégré utilisé pour application qui nous donne la possibilité
programmer en Python. d’exécuter par bloc plusieurs langage de
Il permet l'analyse de code et contient programmation (Python , R …..)
NB : on ne peut pas exécuter le bloc N+1
un débogueur graphique avant le bloc N
 Sommaire:
• Home
• Syntaxe
• Les type de variables
• Les conditions
• Les boucles
• Les sorties
• Les entées
• Les commentaires
• Les variables « manipulation »
• Structure de contrôle « If …. elif …. Else »
• Les operateurs
• Les boucles
• Les conditions
• L’aspect Orienté objet
 HOME

 Pour Python nous n’avons pas besoin du home ou bien du main() par contre pour C
nous en avons besoin.
#il y‘a rien au début du code #include <stdio.h>

print("Hello, World!") int main() {

printf("Hello World!");
#il y ‘ a rien à la fin du code
return 0;
}
 Syntaxe 1/2 : fin de la ligne

 Pour marquer la fin d’instruction en Python il suffit juste de sauter une ligne , en C il on
a besoin de ; .
print("Insruction 1 ......\n") #y’a rien
print("Insruction 2 ......") printf("Insruction 1 ......\n") ;
printf("Insruction 2 ......") ;
 Syntaxe 2/2 : Détermination d’ensemble des instructions

 Pour déterminer un ensemble des instructions appartenant à une boucle ou une condition en
Python on joue juste avec les indentations ‘les espaces', mais en C il faut utiliser les accolades{}.

If True : if (true) {
print("instruction 1 \n") printf("instruction 1 \n");
print("instruction 2 \n") printf("instruction 2 \n");
print("instruction 3 \n")
printf("instruction 3 \n");
}
Toutes les lignes d’une suite
! d’instruction doivent être alignées
entre elles
 Les types de variables 1/2

 Les 3 principaux type de variable pour les 2 langages sont les entiers , les réels et les
chaines de caractères . NB : la fonction type(X) retourne le type de la variable X .
a=3
b = 4.2
c = "bonjour"
print(type(a))
print(type(b))
print(type(c))
 Les types de variables 2/2 : Création et affectation des variables

 En Python , il est largement suffisant d’affecter une valeur à une variable pour la créer , mais
pour C il est obligatoire de déclarer la variable avec son type et après on peut affecter .

x=2 int x ;
y=3 int y ;
z = x +y int z ;
print("x = ",x,"\n y = ",y,"\n z = x + y = ",z) x=2;
Si on crée une variable de type Int en
y=3;
Python, on peut changer de type en z=x+y;
! type Str en affectant une chaine de
caractère , ce qu’on ne peut pas faire
printf(" x = %d \n y = %d \n z = x + y = %d“,
x , y , z );
avec C .
 Les condition

 on verra dans ce slide la syntaxe du «si» « sinon si» et « sinon » pour Python et C , et sont ces dernier qui
imposent la logique conditionnelle pour les instructions qui nécessite une condition vraie avant être exécutées

age = 19 int age = 19 ;

if age >= 18 : if(age >= 18){
print("majeur") printf("majeur");
}
elif age < 18 : else if (age <= 18){
print("mineur") printf("mineur");
else : }
else {
print("no data found ") printf("no data found");
}
 Les boucles

 Les boucles en Python assurent ,comme en C la répétition d’une suite d’instruction tant qu’une condition est vraie. Et
pour les deux langues on trouve la nécessitée de trois éléments : « initialisation » « incrémentation » et « condition
d’entre/sortie »

iter = 1 int iter = 1 ;

while iter <= 5 : while(iter <= 5){
print(iter) printf("%d \n",iter);
iter = iter+1
iter = iter + 1 ;
}
 Les sorties

 La fonction qui est responsable d’afficher des variable en C est Printf est elle oblige un formatage de sortie , par
contre en Python on peut juste mentionner les variables avec la fonction print ainsi qu’on peut donner un format si
on le souhaite .

x=3 int x = 3 ;
c= "k" char c = 'k' ;
print(on affiche ici la variable x qui vaut ", printf( "on affiche ici la variable x qui
x , "et la variable c dans la quelle on a
vaut %d \n et la variable c dans la
stocker la lettre ",c);
quelle on a stocker la lettre %c",x,c);
 Les entrées

 Pour saisir une entrée et la passer comme paramètre , en Python nous avons besoin de la fonction input , en C nous
avons la fonction scanf ,cette dernière a besoin du formatage ainsi qu’on passe l’adresse(&) de la variable en
paramètre .

x = input("saisi la valeur d'entrée : ") int x ;

print(" la valeur de x vaut " ,x)
printf("saisi la valeur d'entree : ");
Toute affectation qu’on effectue via la scanf("%d",&x);
fonction input se fait comme une
printf("la valeur de x vaut %d",x);
! affectation d’un String . D’où, pour
utiliser la valeur numérique du champ
saisi on procède comme suite :
x = int(input("saisi la valeur d'entrée : "))
print(" la valeur de x vaut " ,x)
 Les commentaire

 Le commentaire est l’un des meilleures méthodes qui aide à bien expliquer notre code et on ne prend pas en
considération ce dernier en exécutant le code. Pour python on fait procéder la ligne en commentaire par # ,en C on
fait la même chose mais avec // ,et si nous avons plusieurs ligne on fait les ligne en question entre /*….*/.

a=17 Int a = 17 ;
#on a stocker dans la variable a l’age d’un //on a stocker dans la variable a l’age
etudiant d’un etudiant
/*on a stocker dans
la variable a l’age d’un etudiant*/
 Les variables 1/ 2

Pour utiliser les variable nous avons besoin de respecter plusieurs règles sont les
suivantes :
1. Le nom d’une variable commence avec une lettre ou un Underscore .
2. Le nom d’une variable ne peut pas commencer avec un nombre .
3. Le nom d’une variable doit contenir juste les éléments suivantes : (A-z ; 0-9 ; _)
4. Le nom d’une variable est sensible à la casse c.-à-d. on a une différence entre une
lettre majuscule et minuscule . la
5. On ne peut pas utiliser le tiret 6 (-) La-variable = 3
6. On ne peut pas utiliser l’espace . La variable = 3 La_variable = 3 or Lavariable = 3
 Les variable 2/2

Le 2eme type est les variable à valeur multiple et on peut leurs manipuler comme suite :

Cas 1 : une valeur plusieurs variable

a = b = c = "IDSCC 3"  ce qui affecte "IDSCC 3" à la variable a , b et c .

Cas2 : plusieurs valeurs à plusieurs variable au même temps

les_etudiants = ["ALI " , "IKRAM" , " JAMAL"]

E1 ,E2, E3 = les_etudiants ce qui affecte le 1er élément du tableau à la variable
E1,et de même pour E2 et E3.
 Les types de variable « data types »

Les types de données qu'on verra par la suite sont :

1.Chaines de caractères  str
2.Numérique  int , float , complexe
3.Séquences  list , tuple , range
4.Dictionnaire  dict
5.Sets  set , frozenset
6.Booléen  bool
 Numériques 1/2

Les types numériques que nous avons en pythons les suivantes :

1. Int : entier  1 | 6 | -23
2. Float : réel  0.63 | 1/12 | -153.76
3. Complex : complexe  2j | 7 – j

Et on peut faire un conversion du int vers float et vice-versa en procédant

comme suite :
y=int(3.4)  y vaut 3
z=float(12)  z vaut 12.00
 Numériques 2/2 « l’essaye aléatoire »

Pour avoir un nombre aléatoire dans un intervalle donnée on a besoin

d’importer la bibliothèque random apres on utilise sa fonction randrange()
comme suite :

Import random #importation du bibliothèque

X = random.randrange(1,5) #cette ligne affecte à X une valeur aleatoire

entre 1 et 4
 Séquences 1/12«les listes – list »

Les listes on la forme suivante :

Ma_liste = [element-1 , element-2 , … ,element-n]
La liste est caractérisée par :
1. Tous les éléments de la liste doivent être du même type ainsi que la liste est
modifiable .
2. La liste est modifiable en élément est en nombre .
3. La liste accepte la répétition des éléments .
4. Les element sont ordonnés ,le 1er indice c’est 0 est le 2eme c’est 1 est ainsi de suite
5. On peut avoir une liste dont les éléments sont du même type et de même on peut
trouver une liste ou les éléments ont des type différents .
 Séquences 2/12 «les listes – list »

Soit la liste nommée La_liste , on verra par la suite quelque

fonctions qui vont nous aider à manipuler ces listes comme par
exemple la fonction len(nom_de_liste) .

L = len(La_liste) #va affecter à L le nombre d’element de la liste .

 Séquences 3/12 «les listes – list »

Soit la liste nommée La_liste , on verra par la suite quelque fonctions manipulations
d’accès .
K=La_liste[0] ; J=La_liste[1] vont affecter à K et J le 1er et le 2em éléments de la liste .
K=La_liste[3:8] va affecter à K la suite d’ elements d’indice 3 à 7 (3 inclus 8 ne l’est pas).
K=La_liste[ :11] va affecter à K la suite d’ elements d’indice 0 à 10 (0 inclus 11 ne l’est
pas).
K=La_liste[4: ] va affecter à K la suite d’ elements d’indice 4 jusqu’à la fin de la liste .
K=La_liste[-1] va affecter à K le dernier element de la liste .
 Séquences 4/12 «les listes – list »

Vérification si un element existe dans une liste

Soit le code python suivant :

Les_presents=["ALI" , "JALILA" , ..... ,"ABIR","KARIM"]

Test = ilyass
if Test in Les_presents :
print("Monsieur " , Test , " est présent")

#ce code va afficher le mssg au-dessus si la valeur affecter à variable Test

existe dans la liste d’où la vérification
 Séquences 5/12 «les listes – list »

On peut changer des éléments , on peut insérer des éléments et on peut avoir une extension de la liste .
Cas 1 : changement
La_liste[0] = 12 #ce qui donne que le premier element de la liste devient 12
La_liste[3:4] = [100,200] #ce qui donne que les éléments d’indice 3 et 4 devient respectivement
100 et 200
Cas 1 : insertion
La_liste.insert(2, 14) #on a inserer 14 dans l’emplacement d’indice 2
La_liste.append(23) #on a inserer 23 dans le dernier emplacement (un seul element à la fin de la
liste)
Cas 1 : extension
La_liste.extends(LISTE_2) #ca va ajouter la liste LISTE_2 toute entiere à la fin de notre liste
La_liste.
 Séquences 6/12 «les listes – list »

On peut supprimer un elements de la liste en utilisant de différentes méthodes :

Cas 1 : supprimer avec le nom de l’element
La_liste.remove("ALI") #ça va supprimer le nom ALI de La _liste
Cas2 : supprimer avec l’index
La_liste.pop(3)
del La_liste[3] #ces 2 dernières instruction vont supprimer l’element dont l’index
est 3.
Cas3 : vider la liste
La_liste.clear() #cette fonction va vider la liste.
 Séquences 7/12 «les listes – list »

On verra deux méthodes pour traverser tous les elements d’un liste
1ere méthode :
for e in La_liste :
print(e)

2eme méthode:
for i in range(len(La_liste)): #range(n) est fonction qui donne l’ensemble des nombres entier de 0 à n à traverser
print(La_liste[i])

NB : on peut faire le même traitement avec la boucle while .

 Séquences 8/12 «les listes – list »

Pour classer les elements d’une liste on doit utiliser la fonction sort() et elle donne deux
possibilité d’usage :
1ere possibilté : tri croissant
La_liste_croissante = La_liste.sort() #ce qui va affecter La_liste avec un ordre de tri
croissant .

2eme possibilté : tri decroissant

La_liste_croissante = La_liste.sort(reverse = True) #ce qui va affecter La_liste avec un
ordre de tri decroissant .
 Séquences 9/12 «les listes – list »

Pour copier une liste dans un autre on procède comme suite :

1ere méthode :

Copy_La_liste = La_liste.copy()

2eme méthode :
Copy_La_liste = list(La_liste)
 Séquences 10/12 «les listes – list »

Pour concaténer deux listes on procède comme suite :

1ere méthode :
#soient deux listes L1 et L2 qu’on souhaite concaténer
L1 = L1 + L2

2eme méthode :
#soient deux listes L1 et L2
for e in L2 :
L1.append(e)

3eme méthode :
#soient deux listes L1 et L2
L1.extend(L2)
 Séquences 11/12 «les Tuples – tuple »

Les tuples ont les mêmes caractéristique que les listes , la différence qu’une fois on crée
un tuple on ne peut ni effectuer des changements sur ce tuple ni inserer un element ni
supprimer un elemet et les tuples ont la forme suivante :
Le_tuple = (element-1 , element-2 … element-n)
Et pour la creation d’un tuple , elle se fait en plusieurs méthodes parmi les quelles on
peut siter :
1ere méthode :
Le_tuple =(element-1 , element-2 … ,element-n)
2eme méthode :
La_liste = [element-1,element-2, …. ,element-n]
Le_tuple = tuple(La_liste) #et on peut faire la même conversion tuple list
 Les ensembles « sets »

Les ensembles ou bien les sets sont un cas particulier des tuples dans le quelle on
n’accepte pas les doublants .
les ensembles ou les sets on la forme suivante :
L_ensemble = {Elements-1 , Element-2 , …. , Element-n}

Et on le crée comme suite :

1ere méthode :
l_ensemble = set(Elements-1 , Element-2 , …. , Element-n)
2eme method :
L_ensemble = {Elements-1 , Element-2 , …. , Element-n}
 Les dictionnaires 1/4« dicts »

Les dictionnaires sont des listes dans lesquelles les indices peuvent etre des clés comme indiqué ci-dessous:
Le_dictionnaire = {
clé-1 : element-1 ,
clé-2 : element-2 ,
……
clé-n: element-n
}
exemple :
Etudiant_1 = {
"nom" : "Jabir« ,
"prenom" : "Alami« ,
"age" : 20
}
 Les dictionnaires 2/4« dicts »

Et pour les dictionnaire ils peuvent contient plusieurs types :

Le_dictionnaire = {
"nom" : "ahmen",
" validé " : False,
"année univ " : 2022,
"modules" : [“FR", “ALGEBRA", “INFO"]
}
 Les dictionnaires 3/4« dicts »

L’attribut .keys() et .values() nous aide à extraire respectivement les clés et les valeurs
d’un dictionnaire
Etudiant.keys() = ["clé1", "clé2",…, "clé-n"]
Etudiant.values() = [“valeur associée à clé1", “ val ass à clé2",…, “ val ass à clé-n"]

L’attribut .items() va extraire une liste des couples ( clé , valeur )

L’attribut .update() {("clé-j" :valeur-j)}change la valeur de l’element dont la clé est"clé-j" .
L’attribut .pop("clé1") permet de supprimer l’element dont la clé est « clé1 »
 On peut ajouter une clé et sa valeur en affectant au dictionnaire en l’affectant comme
si la clé est préexistante dans le dictionnaire .
 Les dictionnaires 4/4 « dicts »

Les boucles pour les dictionnaire en Python facilitent beaucoup les choses et on les manipule comme suite :
Soit D un dictionnaire
• for a in D :
print(a) #cette boucle va nous les valeurs du dictionnaire D l’une apres l’autre .

• for a in D.values() :
print(a) # affiche toutes les valeurs de D

• for a in D.keys() :
print(a) # affiche toutes les clés de D

• for a , b in D.items() :
print(a , b) #affiche tous les couples de clé – valeur de D
 Les condition : If …. elif …. else

Généralement le traitement de cas se fait en Python de la manière suivante :

if condition-1 :
traitement-1
elif condition-2 :
traitement-2
..
..
..
elif condition-n :
traitement-n
else :
traitement par défaut si aucune des conditions ni correcte
 Les operateurs 1/2 « logique »

egale : a == b
Different de : a != b
Inferieur strictement de : a < b
Inferieur ou egale à: a <= b
Superieur strictement de : a > b
Superieur ou egale à: a >= b
 Les operateurs 2/2 « arithmétique »

addition : a + b
Soustraction : a - b
Multiplication : a * b
Division : a / b
Puissance : a ** b
Modulo : a % b
 Les boucles 1/3 « Loops »

La boucle while est une boucle qui se repete tant qu’une condition est vraie et on sait pas le nombre de fois
de repetition .
Et elle est de la forme suivante :
initialisation
while condition :
traitement
incrementation
i=1
while i < 6 :
print(i)
i += 1
 Les boucle 2/3 (Break / continue)

break  aide à sortir du boucle au cas où une condition est vérifié .

continue  aide à skipper la suite d’instruction een Passat à l’iteration suivante .

i=1 i=1
while i<10 : while i<10 :
print(i+3) print(i+3)
if i == 3 : if i == 3 :
break continue
i = i+1 i = i+1
 Les boucles 1/ « Loops »

La boucle for elle aide à repeter un suite d’instruction un nombre fini de fois
et qu’on connait ,et elle est de la forme suivante .
for v in intervalle :
traitement à repeter

For x in range(10) :
print(x)
 Les fonctions

On va voir de type de function c’est avec parametres et sans parameres ,

Qui sont comme indiqué au-dessous :

def nom_du_fonction(): def nom_du_fonction(par1 ..par-n):

Traitement Traitement

return var_sortie #facultatif return var_sortie #facultatif

 OO – Orienté Objet 1/3

La programmation Orientée Objet consiste à créer des objets qu’on comptera

par la suite comme type de variables . Voila quelque exemple de quelque
objets connus en python :

Var Value Var Value Var Value

f1 pi i1 2 s1 "GOOGLE"
f2 1/4 i2 50 s2 "Ali12"
f3 1.41 i3 0 s3 "abc"
 OO – Orienté Objet 2/3

Et de mm pour nos objets qui seront des types de variables , c’est à nous donner la
structure de ces objet qui se compose de 3 parties : nom – attributs – methods
class nom_class : Etudiant
type1 attribut1
Nom
….
Note1
typeN attributN
def methode1:  Note2

… Moyenne()
def methodeN:
…
 OO – Orienté Objet 3/3

Créons un exemple vu auparavant : On utilise la fonction __init__() qui sert à initialiser les
attribut ainsi que l’attribut self qui indique que l’attribut attaqué est associé à cet objet
nommé Objet coutant .

class Etudiant:
def __init__(self,nm,n1,n2):
self.nom = nm
self.note1 = n1
self.note2 = n2
self.moyenne = 0
def m(self):
print((self.note1+self.note2)/2)