Vous êtes sur la page 1sur 88

PYTHON

By Asmaa Kassid
Popularité des langages de programmation Présentation de python

Python a gagné en popularité ces derniers temps,

Pourquoi ???
Facile à apprendre

Rapide à mettre en œuvre

Puissant
Présentation de python
Historique du langage
 Python est développé depuis 1991 par Guido van Rossum et de nombreux
contributeurs bénévoles.

La Python Software Foundation -- l’association qui organise le


développement de Python et anime la communauté de
développeurs et d’utilisateurs

Le nom Python vient d’un hommage à la série télévisée Monty


Python’s Flying Circus .
Présentation de python
Ce qu'on peut faire avec Python 

1/ De petits programmes très simples, appelés scripts, chargés


d'une mission très précise sur votre ordinateur ;

2/ Des programmes complets, comme des jeux, des


suites bureautiques, des logiciels multimédias, des
clients de messagerie…

3/ Des projets très complexes, comme des progiciels


(ensemble de plusieurs logiciels pouvant fonctionner ensemble,
principalement utilisés dans le monde professionnel).
Ce qu'on peut faire avec Python 

Python permet de faire des choses vraiment incroyables, on peut catégoriser ces
utilisations en 3 grandes catégories :

 Développement web (Django et Flask )

 Data Science – incluant le machine learning, l’analyse de données ainsi


que la visualisation de données,

 Scripting
Présentation de python
Caractéristiques
Open source

Portable:
linux/unix/Windows/OS propriétaire (mac; Ms-Dos)
Généraliste:
il peut être utilisé dans tous les domaines : écriture d'applications pour le Web/
programmes de calculs mathématiques /Interfaces graphiques /programmation de scripts
systèmes, etc.

Simple & facile:


un langage de haut niveau/ /L’écriture des blocs d'instructions est indentée

orienté-objet:  
(POO) permet de créer des entités (objets) que l'on peut manipuler .
Les objets peuvent interagir entre eux.

Dynamique:
Typage dynamique des variables(déclaration pas nécessaire)
Présentation de python
Techniques de production des programmes

Technique 1: Compilation

Source Compilateur Objet exécuteur résultat

Technique 2: interprétation

Source Interpréteur résultat

Technique 3: Technique de production de Python: Semi-interprété

Source Compilateur Bytecode Interpréteur résultat


Présentation de python

Qui utilise Python?

 Google (Guido van Rossum a travaillé pour Google de 2005 à 2012),

 Yahoo,

 Microsoft,

 la Nasa revendique (exige) l'utilisation de Python,

 youtube
Présentation de python
Différentes versions
Il existe 2 familles de versions

2.X 3.X

Durant les années a partir de 2001 Depuis 2009: Python 3.x n'est pas une simple
amélioration ou extension de Python 2.x.
2.3, 2.5, 2.6…

Tant que les auteurs de librairies


n'auront pas effectué la migration,
les deux versions devront coexister.
Différentes versions
Différences Python 2 et Python 3
Installation de python

Sur le site www.python.org/downloads


Interpréteur python
Avec IDLE sous Windows, votre environnement de travail ressemblera à celui-ci
Pour sortir de l’interpréteur, entrez simplement :  exit()  (attention aux parenthèses !) puis appuyez sur la touche entrée.
 

le signal d’invite

Ou

prompt principal

Python est prêt à exécuter


une commande.
Les Variables: définition Eléments de base

Il est impossible d’écrire un programme sans utiliser de variable.

Une variable est une sorte de boite virtuelle dans laquelle on peut mettre une (ou plusieurs)
donnée(s). L'idée est de stocker temporairement une donnée pour travailler avec.

Une variable est caractérisée par :

•un identificateur : il peut contenir des lettres, des


chiffres, des blancs soulignés mais il ne peut commencer
par un chiffre (nom).
•un type : c’est une information sur le contenu de la
variable qui indique à l’interpréteur python, la manière de
manipuler cette information.
Les Variables: nommage Eléments de base

Les noms des variables obéissent à des règles :

 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é).

 La casse est significative


Les Variables: nommage Eléments de base

 vous ne pouvez pas utiliser comme nom de variables les 33 « mots réservés »
ci-dessous (ils sont utilisés par le langage lui-même) :

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
Les Variables: nommage Eléments de base

 Il est important d’utiliser une politique cohérente de


nommage des identificateurs.
— nom_de_ma_variable pour les variables ;
— NOM_DE_MA_CONSTANTE pour les constantes ;
— maFonction, maMethode pour les fonctions et les méthodes ;
— MaClasse pour les classes ;
— UneExceptionError pour les exceptions ;
— nom_de_module pour les modules et pour tous les autres
identificateurs
Les Variables: type Eléments de base

le typage des variables sous Python est un typage dynamique


Les types principaux sont :

x=3 -- les entiers (integer ou int),


y = 3.0
print("x =", x, type(x)) -- les réels (float)
print("y =", y, type(y))
-- les chaînes de caractères (string )

-- booléen

Type « rien » ou None

signifie qu’une variable ne contient rien. La s = None


variable est de type None et est égale à None. print(s) # affiche None
Certaines fonctions utilisent cette convention
lorsqu’il leur est impossible de retourner un
résultat.
Eléments de base
>>> age = 30 >>> age = 30 >>> age = 30
>>> age = age + 10 >>> age2 = age
>>> age
>>> age >>> age2

>>> age = "J'ai 30 ans" >>> age = age + " et je suis encore jeune! "   >>> age = "jeune"
>>> age >>> age >>> age * 3

x=4<5
>>> age = "J'ai 30 ans"
print(x)
>>> age "J'ai 30 ans"
>>> age + 1 print(not x)

>>> text= ‘python’ >>> text= ‘python’


>>> print(text) >>> print(text[4]) (0 1 2 3 4 )
Conversion de types Eléments de base

En programmation, on est souvent amené à convertir les types, c'est-à-dire passer


d'un type numérique à une chaîne de caractères ou vice-versa. En Python, rien de
plus simple avec les fonctions int(),float(),str()

Toute conversion d'une variable d'un type en un autre est


appelé casting en anglais,
 Voici la liste des opérateurs qui s’appliquent aux booléens. Eléments de base

Voici la liste des opérateurs qui s’appliquent aux chaines de caractères


Eléments de base

Les extra-caractères les plus couramment utilisés à


l’intérieur d’une chaîne de caractères 
Affectation (ou assignation ) Eléments de base

 En Python comme dans de nombreux autres langages, l’opération


d’affectation est représentée par le signe égale =

le membre de gauche reçoit le membre de droite

>>> a = 3 * 7

>>> a >>> a = a+1


21
>>> b = 2 * 2
>>> a = a-1
>>> b
4
>>> a = b + 5

>>> a
9
Eléments de base
L’affectation réalise les opération suivantes

 crée et mémorise un nom de variable ;

 lui attribuer un type bien déterminé (ce point sera explicité à la page
suivante) ;

 créer et mémoriser une valeur particulière ;

 établir un lien (par un système interne de pointeurs) entre le nom de la


variable et l’emplacement mémoire de la valeur correspondante.
Affectation :Quelques forme d’affectation Eléments de base

>>> v = 4 # affectation simple

>>> v += 2 # affectation augmentée. Idem à v = v + 2 si v est déjà référencé


>>> v
6
>>> c = d = 8 # d reçoit 8 puis c reçoit d (c et d sont des alias)
>>> c, d
(8, 8)
>>> e, f = 2.7, 5.1 # affectation parallèle d’un tuple
>>> (e, f)
(2.7, 5.1)
>>> g, h = [’G’, ’H’] # affectation parallèle d’une liste
>>> [g, h]
[’G’, ’H’]
>>> a = 3
>>> a, b = a + 2, a * 2 # toutes les expressions sont évaluées avant la première affectation
>>> a, b
(5, 6)
Affectation illustrée

Les affectations relient les identificateurs aux données :


si une donnée en mémoire n’est plus reliée, le ramasse-
miette es (garbage collector) de Python la supprime
automatiquement (car son nombre de références tombe
à zéro)
Trucs et astuces

Python propose un moyen simple On peut aussi affecter une même valeur à
de permuter deux variables plusieurs variables

>>> a=5
>>> b = 32 >>> x = y = 3
>>> a,b = b,a # permutation >>> x
>>> a 3
32 >>> y
>>> b 3
5 >>>
>>>
Quizz Eléments de base
Lequel de ces mots ne pouvez-vous pas utiliser comme nom de variable ?

 je ne sais pas  je ne sais pas  je ne sais pas


 quatreAs  US$
 Pass
 quatre_as  Usdollars
 Password  4As  USDOLLARS
 Pas9  QuatreAs  US_dollars
 pas

 je ne sais pas  je ne sais pas


 0  _x
 0.75  X
 0,75  x_
 1  Ces trois noms
sont autorisés.
Quizz:corrigé Eléments de base
Lequel de ces mots ne pouvez-vous pas utiliser comme nom de variable ?

 je ne sais pas
 je ne sais pas
 je ne sais pas  US$
 quatreAs
 Pass  quatre_as
 Usdollars
 4As  USDOLLARS
 Password
 QuatreAs  US_dollar
 Pas9
 pas Un nom de variable doit On ne peut pas utiliser
commencer par une de caractères spéciaux
un mot réservé lettre

¾= ….???
 je ne sais pas  je ne sais pas
0  _x
0.75  X
0,75  x_
1  Ces trois noms sont
autorisés

En Python 3, 3/4 est On peut commencer un


un nombre réel. En nom de variable par
Python 2, la bonne _.
réponse aurait été 0
Les Entrées-Sorties Eléments de base

Entrée- saisir ou entrer Sortie  afficher ou sortir

>>> i = input(”Entrez un entier : ”) >>> a, b = 2, 5


Entrez un entier : 3 >>> print(a, b)
>>> i 25
’3’ >>> print(”Somme :”, a + b)
>>> iplus = int(input(”Entrez un entier : ”)) + 1 Somme : 7
Entrez un entier : 3 >>>> print(a - b, ”est la différence”)
>>> iplus -3 est la différence
4
Affichage:print
 La fonction print() peut également afficher le contenu d'une variable quel que
soit son type

 Il est également possible d'afficher le contenu de plusieurs variables


Écriture formatée
 La méthode .format() permet une meilleure organisation de l'affichage des
variables (nous expliquerons à la fin de ce chapitre ce que le terme « méthode »
signifie en Python).

• 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) fournie la liste des variables à insérer 
Liste Eléments de base

Une liste est une structure de données qui contient une série de valeurs

Python autorise la construction de liste contenant des valeurs de


type différent (flexibilité)

Déclaration
>>> animaux = ['girafe','tigre','singe','souris’]

Une liste est déclarée par une série de séparées par >>> tailles = [5, 2.5, 1.75, 0.15]
des virgules, et le tout encadré par des crochets
>>> mixte = ['girafe', 5, 'souris', 0.15]

n’oubliez pas les guillemets, simples ou doubles, s’il s’agit


de chaînes de caractères
Liste :* Utilisation Eléments de base
>>> animaux = ['girafe','tigre','singe','souris’]
>>> animaux[1]
>>> animaux[2]
>>> animaux[4] Indice

Soyez très attentifs au fait que les indices d’une liste


de n éléments commence à 0 et se termine à n-1

Liste :* Opération
>>> ani1 = ['girafe','tigre’] + : concaténation
>>> ani2 = ['singe','souris’]
>>> ani1 + ani2
>>> ani1 * ani2
*  la duplication
Liste :* Utilisation

Liste : ['girafe', 'tigre', 'singe', 'souris’]


indice positif : 0 1 2 3
indice négatif : -4 -3 -2 -1

Les indices négatifs reviennent à compter à partir de la fin

Accéder au dernier élément d’une liste à l’aide de l’indice -1

>>> animaux = ['girafe','tigre','singe','souris’]


>>> animaux[-1]
>>> animaux[-2]
Liste : fonctions Len() range() et List()

 L’instruction len() vous permet de connaître la longueur d’une liste

>>> animaux = ['girafe', 'tigre', 'singe','souris’]


>>> len(animaux)

 L’instruction range() est une fonction spéciale en Python qui va nous permettre de générer des nombres
entiers compris dans un intervalle lorsqu’elle est utilisée en combinaison avec la fonction list().

>>> list(range(10))

>>> list(range(0,5))

>>> list(range(15,20))

>>> list(range(0 , 1000 , 200))


range([début,] fin[, pas])
Listes de listes

>>> enclos1 = ['girafe', 4]


sous-liste
>>> enclos2 = ['tigre', 2]
>>> enclos3 = ['singe', 5]
>>> zoo = [enclos1, enclos2, enclos3]
>>> zoo

Pour accéder à un élément de la liste, on utilise l’indiçage habituel :

>>> zoo[1]

Pour accéder à un élément de la sous-liste, on utilise un double indiçage :


>>> zoo[1][0]
'tigre’
>>> zoo[1][1]
2
Exercice sur les listes

créer une liste d’au moins 5 entiers puis successivement :

1 affiche la valeur de         


2 modifie la liste en remplaçant         par 17 et          par la somme des cases
voisines          et         

L = [8, 5, 6, 1, 17]
print (L[4])
L[1] = 17
L[3] = L[2] + L[4]
print (L)
Exercice sur les listes
 Écrire un programme qui échange les valeurs de la première et de la dernière
case d’une liste quelconque non vide.
 L = [6, 12, 18, 5]

#utilisation d'une variable auxiliaire


#aux=x
#x=y
#y=aux
L = [6, 12, 18, 5]
l = len(L)
aux = L[0]
L[0] = L[l-1]
L[l-1] = aux
print (L)
Les Listes
 On utilise la méthode append pour ajouter un élément à la fin d'une liste.
 On utilise la méthode insert pour Insérer un élément dans la liste
 On utilise la méthode extend pour concaténer deux listes.
 on utilise la méthode reverse pour Inverser l’ordre des éléments de la liste, en place.
 On utilise la méthode pop pour supprimer un élément de la liste a partir de sa position
 On utilise la méthode remove pour parcourir la liste et en retirer l’élément désiré
 On utilise la méthode sort pour Classer les éléments de la liste sur place
 On utilise la méthode index(x) pour Retourner la position du premier élément de la liste ayant la valeur x

>>> liste = [66.25, 333, 333, 1, 1234.5] >>> liste.reverse()


>>> print liste.count(333), liste.count(66.25), liste.count('x') >>> liste
210 [333, 1234.5, 1, 333, -1, 66.25]
>>> liste.insert >>> liste.sort()
(2, -1) >>> liste
>>> liste.append(333) [-1, 1, 66.25, 333, 333, 1234.5]
>>> liste >>> liste.pop() 1234.5
[66.25, 333, -1, 333, 1, 1234.5, 333] >>> liste
>>> liste.index(333) [-1, 1, 66.25, 333, 333]
1
>>> liste.remove(333)
>>> liste
[66.25, -1, 333, 1, 1234.5, 333]
Le parcours de listes: boucler une liste

>>> liste = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']

While For

>>> i = 0 >>> for lettre in liste:


>>> while i < len(liste):
print(lettre)
print(liste[i])
i += 1

for lettre in enumerate(liste):


... Print ( lettre)
...

Si on veut récupérer l'index

Les valeurs retournées par la boucle sont des tuples.


Les Tuples

Les tuples sont des collections d’éléments, mais leurs éléments sont fixés .

Une fois créé, on peux pas ajouter de nouveaux éléments, supprimer des éléments,
remplacer des éléments, ou réorganiser les éléments du tuple

 
Syntaxe :Un tuple se définit comme une liste, sauf qu'on
utilise comme délimiteur des parenthèses au lieu des
crochets.

Les tuples sont des listes immuables

On utilisera un Tuple pour définir des sortes de constantes qui n'ont donc pas vocation à
changer
Les Tuples:exemples de création

 t1 = () # Crée un tuple vide


 t2 = (1, 3, 5) # Crée un tuple constitué de trois éléments

 t3 = (2,) # Crée un tuple constitué d’un seul élément

 t3 = tuple([2 * x for x in range(1, 5)]) # Crée un tuple à partir d’une liste

 t4 = tuple("abac") # t4 est ('a', 'b', 'a', 'c') # Créer un tuple à partir d'une chaîne de caractères

La liste ci-dessous résume les opérations utilisées avec les tuples.

x in s : Vrai si l’élément x est dans le tuple s.


x not in s : Vrai si l’élément x ne figure pas dans le tuple s.
s1 + s2 : Concaténer deux tuples s1 et s2.
s * n, n * s : Crée un tuple composé de n copies concaténées de s.
s[i] : Elément d’indice i dans le tuple s.
s[i : j] : Tranche du tuple s dès l’indice i à l’indice j – 1.
len(s) : Le nombre d’éléments dans le tuple s.
min(s) : Le plus petit élément dans le tuple s.
max(s) : Le plus grand élément dans le tuple s.
sum(s) : Somme de tous les éléments de s.
Boucle for : Traverse les éléments du tuple s de gauche à droite.
<, <=, >, >=, =, != : Compare deux tuples
Les Tuples:exercice
tuple2 = tuple([7, 1, 2, 23, 4, 5])

 tuple1 = ("green", "red", "blue") # Crée un tuple print("la longueur est ", len(tuple2))
Crée un tuple2 à partir d’une liste(chiffres)
print("la longueur est ", len(tuple2))
 Afficher la longueur de le tuple 2
print("le minimum est ", min(tuple2))
 Afficher le maximum de le tuple 2
print("la somme est ", sum(tuple2))
 Afficher le minimum de le tuple 2
 Afficher la somme de le tuple 2 print("Le premier élément est", tuple2[0])
 Afficher le premier élément de le tuple 2
tuple3 = tuple1 + tuple2
 Combiner les deux tuples 1 et 2
tuple3 = 2 * tuple1
 Dupliquer le tuple 1
print(tuple2[2 : 4])
 afficher une tranche d’un tuple
print(tuple1[-1])
 afficher le dernier élément du tuple 1
print(2 in tuple2)
 Assurer que le chiffre 2 est dans le tuple2
 Afficher les éléments du tuple 1 on utilisant la
for v in tuple1:
boucle for
print(v, )
 convertir un tuple en une liste
liste1 = list(tuple2)
 tuple4 = tuple(liste1)
print(tuple4 == tuple5)
 tuple5 = tuple(liste1)

 Comparer tuple2 et tuple4.


Supposons que votre programme a besoin de stocker toutes les informations
(CIN, nom, prénom, …..) des élèves de votre classe.
En addition, le programme doit accéder aux informations d’un élève en utilisant
seulement son numéro de CIN seulement.

Quelle est la structure de donnée convenable pour satisfaire ces besoins ?


Dictionnaire
 Un dictionnaire en python est une sorte de liste mais au lieu d'utiliser
des index , on utilise des clés , c'est à dire des valeurs autres que
numériques.

Le plus simple est de considérer les dictionnaires comme une collection qui stocke
des paires clé/valeurs

uniques (au sein d’un dictionnaire)

Il permet:
1/une récupération rapide( recherche )
2/suppression et mise à jour de la valeur à l’aide de sa
clé.
Dictionnaire via liste
La liste Le dictionnaire

*Objet conteneur d’autres objets. *Objet conteneur d’autres objets .


*Pour accéder aux objets contenus, il faut *Mais aucune structure ordonnée.
connaître leur position dans la liste. *Pour accéder aux objets contenus, on
*Cette position se traduit par des entiers, n’utilise pas nécessairement des indices
appelés indices, compris entre 0 (inclus) mais des clés qui peuvent être de bien des
et la taille de la liste (non incluse). types distincts.

- Dans une liste, les indices sont des nombres entiers.

-Dans un dictionnaire, la clé doit être un objet hashable


(exemple : entier, flottant, logique, complexe, chaîne de
caractères, tuple). La partie « valeur » peut être de tout
type.
Dictionnaire: Création et édition

A l’aide de la fonction “dict()” A l’aide des accolades “{}”

firstdic= dict([('mom', 'Marge'), ('dad', 'Homer'), ('sister', 'Lisa')]) firstdic= {'dad':'Homer', 'mom':'Marge', 'sister':'Lisa'}

firstdict= {'dad':('Homer',38, 'Like swimming), 'mom':'Marge', 'sister':'Lisa'}

Les parenthèses délimitent les tuples, les crochets délimitent les listes et les accolades {}
délimitent les dictionnaires.
Dictionnaire: Manipulation

Ajout, Modification , Récupération de valeurs

Pour ajouter un élément à un dictionnaire: Tester si une clé est dans le dictionnaire:
first[clé]= valeur firstdict.has_key('dad')

Obtenir une liste des clés:


firstdic.keys()
Ajouter des valeurs à une clé déjà existante:
firstdic['dad'].append('Like swimming')
Obtenir une liste des valeurs:
firstdic.values()
Vider un dictionnaire:
firstdic.clear()
Obtenir une valeur associée à une clé donnée:
firstdic['dad']

Supprimer une clé:


Changer une valeur: del firstdic['mom']
firstdic['sister'] = 'Maggie'
Instruction de contrôle: instructions conditionnelles

 Les instructions conditionnelles permettent de n'exécuter une partie du


programme que si une condition donnée est satisfaite.

if if condition

instructions

Prenon un exemple, on va donner une valeur à une variable a , si cette valeur est supérieur à 5, alors
on va incrémenter la valeur de 1

>>> a = 3
>>> a = 10
>>> if a > 5:
>>> if a > 5:
... a = a + 1
... a = a + 1
...
...
>>> a
>>> a
3 On décrémente???
11
Instruction de contrôle: instructions conditionnelles

if condition
instructions
if

if else
condition

instructions Elif condition


instructions
else
instructions else
instructions

>>> a = 3 >>> a = 5
>>> if a > 5: >>> if a > 5:
... a = a + 1 ... a = a + 1
... else: ... elif a == 5:
... a = a - 1 ... a = a + 1000
... ... else:
>>> a ... a = a - 1
2 si a = 5 ?????? ...
>>> a
1005
Instruction de contrôle: instructions conditionnelles
les opérateurs de
comparaison

 La condition évaluée après l’instruction if peut contenir les opérateurs de


comparaison suivants :
 x == y # x est égal à y
 x != y # x est différent de y
 x>y # x est plus grand que y
 x<y # x est plus petit que y
 x >= y # x est plus grand que, ou égal à y
 x <= y # x est plus petit que, ou égal à y

La nature du résultat de cette comparaison ???


Variable booléenne
 Une variable contenant une valeur booléenne est connue sous le nom d’une variable
booléenne.
 Le type de données Boolean est utilisé pour représenter les valeurs logiques ( vrai ou
faux).

 Python utilise 1 pour représenter True et 0 pour faux. Vous pouvez utiliser la fonction
int pour convertir une valeur booléenne à un nombre entier.

 Par exemple, l’instruction print(int(True)) affiche 1 et l’instruction print(int(False))


affiche 0.

 Vous pouvez également utiliser la fonction bool pour convertir une valeur numérique en
une valeur booléenne.

 La fonction renvoie False si la valeur est 0; sinon, elle retourne toujours True.
Par exemple, l’instruction print(bool(0)) affiche False et l’instruction print(bool(4))
affiche True.
Variable booléenne
La liste suivante répertorie les opérateurs booléens.
 not: négation logique
 and: conjonction logique
 or:  disjonction logique

Ecrire un programme qui vérifie :

si un nombre est divisible par 2 et 3, par 2 ou 3, et par 2 ou 3 mais pas les deux.

nombre = eval(input("Entrer un entier: "))

if nombre % 2 == 0 and nombre % 3 == 0:

print(nombre, " est divisible par 2 et 3")


if nombre % 2 == 0 or nombre % 3 == 0:

print(nombre, "est divisible par 2 ou 3")


if (nombre % 2 == 0 or nombre % 3 == 0) and not (nombre % 2 == 0 and nombre % 3 == 0):

print(nombre, "est divisible par 2 ou 3, mais pas les deux")


Instruction de contrôle: instructions répétitives

 Une boucle ( ou loop ) vous permet de répéter à l'infini des instructions selon


vos besoins.

Ecrire un programme qui affiche une chaîne de caractères (par exemple « Python est un langage
de programmation très puisson! ») 100 fois

i=0
while i< 100:
print(" « Python est un langage de programmation très puisson! »’’)
i = i+ 1

While: exécute des instructions à plusieurs reprises tant qu’une condition reste vraie

while condition-de-continuation-de-la-boucle:
Instruction(s)
Instruction de contrôle: instructions répétitives

 For: Lorsque l’on souhaite répéter un nombre donné de fois la même


instruction ou le même bloc d’instructions, la commande for est la plus
appropriée.

for i in range(a,b,k) : La fonction range(a, b) renvoie la séquence de nombres entiers


Instruction(s) a, a+ 1, a+2, …, b-2, et b-1.
K c’est le pas

for i in range(100): # pour i allant de 0 à 100

print("« Python est un langage de programmation très


puisson! »")

La boucle for permet de faire des itérations sur un élément, comme une chaine de caractères 

v = "Bonjour toi "


for i in v:
print(i)
Boucles imbriquées: instructions composées

 Une boucle peut être imbriquée dans une autre boucle.


 Les boucles emboîtées se composent d’une boucle externe et une ou
plusieurs boucles internes.
 Chaque fois que la boucle extérieure est itérée, les boucles internes sont
exécutées en entier.

Que affiche le programme suivant : print("Table de Multiplication")


# Afficher l'en-tête de la table composé des chiffres: 1 à 9
print("\t|", end = ‘’) print("\t|", end = ‘’)
for j in range(1, 10): for j in range(1, 10):
print("\t", j, end = ‘’) print("\t", j, end = ‘’)
print() print() # Aller vers une nouvelle ligne
print("———————————————————")
print("—————————————————") # Affichage du corps de table
for i in range(1, 10): for i in range(1, 10):
print(i, "\t|", end = ‘’) print(i, "\t|", end = ‘’)
for j in range(1, 10): for j in range(1, 10):
print('\t', i*j, end = ‘’) # Afficher le produit et l’aligner correctement
print() print('\t', i*j, end = ‘’)
print() # Aller vers une nouvelle ligne
Les instructions Break/Continue
n=1
n=0
while n <= 1000000:
if n % 38 == 0 and n % 46 == 0: while n <= 100:

break n += 1
n += 1
if n % 2 != 0:
Print (n, "est le plus petit nombre divisible par 38 et 46")
continue

print(n)

-La première instruction augmente la valeur de la variable n.

-Si celle-ci est impaire, on arrête d'exécuter le corps de la boucle


et on passe directement au tour suivant.

- Sinon, on affiche la valeur de n.


On a besoin de trouver la somme des entiers de 1 à 10, 20 à 37 et 35 à 49. Si vous créez un
programme pour calculer la somme de ces trois intervalles de nombres.

sum = 0
for i in range(1, 11):
sum += i
print("La somme de 1 à 10 est ", sum)

sum = 0
for i in range(20, 38):
sum += i
print("La somme de 20 à 37 est ", sum)

sum = 0
for i in range(35, 50):
sum += i
print("La somme de 35 à 49 est ", sum)
Les fonctions
Les fonctions peuvent être utilisées pour définir un code réutilisable, d’organiser et de simplifier les
programmes.

Une fonction (ou function ) est une suite d'instructions que l'on peut appeler avec un


nom.

def sum(i1, i2): # fonction calculant la


somme de i1 à i2
def nomDeLaFonction (liste de paramètres): result = 0
...
bloc d'instructions for i in range(i1, i2 + 1):
... result += i
return result

print("La somme de 1 à 10 est ", sum(1,10))


print("La somme de 20 à 37 est ", sum(20, 37))
print("La somme de 35 à 49 est ", sum(35, 49))
Les fonctions: paramètres(arguments)

NOTEZ BIEN QUE L’EXECUTION DU CORPS D’UNE FONCTION S’ARRETE


LORSQUE L’INSTRUCTION RETURN EST EXECUTEE.

>>> def addition(a, b): >>> def multiplication(a, b):


… return a+b … return 30 + a + b
... ...
>>> addition(1, 2) >>> multiplication (1)

Ces arguments peuvent être des variables, mais aussi des fonctions,
appelées alors "fonctions de rappel" 

def operation(x, y, f):


return f(x, y)

operation(3, 4, addition)

operation(3, 4, multiplication)
Variables locales variables globales
Définition des variables à l'intérieur du corps d'une Définition des variables  à l'extérieur du corps  d'une
fonction fonction 
Accessibles qu'à la fonction elle-même Leur contenu est « visible » de l'intérieur d'une fonction, mais la
fonction ne peut pas le modifier

p, q = 15, 38
>>> def numb():
... p = 20
>>>numb() ????
... print p, q
>>>print p, q ?????

>>> def numb():


... globale p = 20
... print p, q
Modules:

 comment utiliser une même fonction dans


plusieurs programmes différents ?

Module.py
from module import carre
a=5
def carre(valeur):
u = carre(a)
resultat = valeur**2
return resultat print("le carre vaut", u)

def cube(valeur): from module import carre,cube


Importer les fonctions
resultat = valeur**3 from module import *
return resultat
Modules: importer le module

import module
a=5
u = mod.carre(a)
print("le carre vaut", u)
v = mod.cube(a)
("le cube vaut", v)

Il faut préciser le nom du module devant la fonction

importer le module avec un alias import module as mod

importer une fonction d’un avec un alias from module import carre as ca
Modules:
Le fichier module.py doit être dans le même répertoire que le programme
principal
ou bien
se trouve dans le « path » de Python).

Sinon il faut préciser à l’interpréteur python où il


doit chercher ce module

import sys

La variable sys.path contient les
répertoires où python va chercher sys.path.append("répertoire où se trouve le module à importer")
les modules

import nom_module
Module: attributs communs
Une fois importés, tous les modules possèdent cinq attributs qui contiennent des
informations comme leur nom, le chemin du fichier correspondant, l’aide associée.

__all__ Contient toutes les variables, fonctions,


classes du module
__builtins__ Ce dictionnaire contient toutes les
fonctions et classes inhérentes au
langage python utilisées par le module.

__doc__ Contient l’aide associée au module.

__file__ Contient le nom du fichier qui définit le


module.
__name__ Cette variable contient a priori le nom du
module sauf si le module est le point
d’entrée du programme auquel cas cette
variable contient __main__.

import module
Exemple:
Print (module.__name__, module.__doc__)
Package
C’est Un dossier qui rassemble un grand nombres de modules.

import package1.module1
u = package1.module1.fonction1(3)
  print(‘’résultat est’’)
Exemple: module turtle

Le module turtle permet d’illustrer les boucles de façon ludique. Il offre la


possibilité 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 simples17 . Écrivez un script avec les
exemples suivants, en faisant varier les paramètres :
Exercice

Créons un module polygone contenant des fonctions pour


dessiner des formes tel que un polygone et un carré
POO: orienté objet

Apparue dans les années 60 quant à elle, la


programmation orientée objet (POO) est un paradigme
de programmation

  une façon de concevoir un programme informatique, reposant sur


l’idée qu’un programme est composé d’objets interagissant les uns
avec les autres

Une donnée constituée de diverses propriétés, et


pouvant être manipulée par différentes opérations
Objet
 un objet est constitué de 3 caractéristiques :

— Un type, qui identifie le rôle de l’objet (int, str et list sont des exemples de types
d’objets) ;
— Des attributs, qui sont les propriétés de l’objet ;
— Des méthodes, les opérations qui s’appliquent sur l’objet.

Exemple

>>> number = 5  On instancie une variable `number`de type `int`


>>> number.numerator  `numerator` est un attribut de `number`
>>> values = []  Variable `values` de type `list`
>>> values.append(number) `append` est une méthode de `values`
>>> values
Classe:type
*Tout objet est associé à un type.

*Un type définit la sémantique d’un objet.

*Ce nouveau type s'appelle classe.


*Une classe décrit la structure des objets du type qu’elle définit : quelles méthodes vont être
applicables sur ces objets.

class NomDeLaClasse:
<instruction 1>
<instruction 2>
.
.
.
<instruction N>
Classe
--nous utiliserons un type/classe Utilisateur représentant un utilisateur sur un logiciel

class Utilisateur:

pass

--Pour créer un objet de type Utilisateur, il nous suffit de procéder ainsi

Ahmed =Utilisateur( )
Classe: Attribut
 Un objet se constitue de plusieurs attributs ( valeurs propres à l’objet) .

un identifiant (id),
un nom (name)
un mot de passe (password).

En Python, nous pouvons facilement associer des valeurs à nos objets :

class Utilisateur:
pass
ahmed = Utilisateur()
ahmed.id = 1
ahmed.name = 'john'
ahmed.password = '12345'
print('Bonjour, je suis {}.'.format(ahmed.name)
print('Mon id est le {}.'.format(ahmed.id)
print('Mon mot de passe est {}.'.format(ahmed.password))
Classe:Méthodes
--les méthodes sont les opérations applicables sur les objets Des fonctions qui reçoivent
notre objet en premier paramètre.

def user_check_pwd(user, password):


Exemple
return user.password == password

Utilisateur
class Utilisateur:

def check_pwd(self, password):


Id
Password return self.password == password
name

user_check_pwd() Quel est ce self ??


Classe/objet
Self  l’objet sur lequel on applique la méthode//Les autres paramètres de la
méthode arrivent après

un premier argument qui représente, dans la méthode, l'objet = l'instance particulière.
Deux syntaxe pour appeler les méthodes :

objet.methode() syntaxe courante (implicitement transformée dans


la deuxième)
Classe.methode(objet)

ahmed.check_pwd('12345')
>>> john = Utilisateur()
Utilisateur.check_pwd(ahmed, '12345'). >>> john.id = 1
>>> john.name = 'john'
>>> john.password = '12345'
>>> john.check_pwd('toto')
>>> john.check_pwd('12345')
Classe/objet

 dans le corps de la méthode check_pwd, c est quoi la différence entre


password et self.password ??

l’attribut de notre objet

le paramètre reçu par la méthode


Classe : appelle de classe

Quand on appelle une classe :

 un nouvel objet de ce type est construit en mémoire,


puis initialisé = assigner des valeurs au attributs de l’objet

L’objet est initialisé à l’aide d’une méthode spéciale de sa classe,

__init__ : reçoit les arguments passés lors de l’instanciation

Instancier une classe est semblable à un appel de


fonction
Classe : appelle de classe(instantiation)

Exemple

class Utilisateur :
def __init__(self, id, name, password):
self.id = id
le paramètre self, qui est donc utilisé pour modifier les
self.name = name attributs de l’objet
self.password = password
ahmed= Utilisateur(1, ‘ahmed', '12345')
def check_pwd(self, password):
return self.password == password
Classe: Attributs
On peut définir des attributs pour les classes aussi (class attributes = attributs de classe), par
affectation.
Ils sont en commun pour toutes les objet crée par la classe. Souvent utilisés
pour les « constantes » du type.

class Cercle:
PI = 3.14159

def _init__(self, r): self.rayon = r


def aire(self)
return Cercle.PI * self.rayon ** 2

print('La valeur de PI est {}'.format(Cercle.PI)) c = Cercle(2.5)


print('rayon = {}, aire = {}'.format(c.rayon, c.aire()))
Classe: objet Vecteur

Un objet peut être composé par des autres objets. x


y
Exemple : un rectangle est défini par deux points.
Hauteur() Rectangle
a = Vecteur(1, 2) largeur()
p1 = Vecteur
b = Vecteur(5, 4)
x=1
class Rectangle: y=2
def init (self, p1, p2): self.p1
= p1 p2 = Vecteur
self.p2 = p2 x=4
y=3
def aire(self):
largeur = self.p2.x – self.p1.x hauteur =
self.p2.y – self.p1.y return largeur * aire()
hauteur
rect = Rectangle(a, b)
print(rect.aire())
La fonction ‘’dir’’
 Parfois il est intéressant de decortiquer un objet pour résoudre à un bug ou
pour comprendre un script.
 La fonction dir vous donne un aperçu des méthodes de l'objet:
>>> dir(utilisateur)

L'attribut spécial __dict__


 Cet attribut spécial vous donne les valeurs des attributs de l'instance:
>>> utilisateur.__dict__
L'héritage de classe

L'héritage est un concept très utile. Cela permet de créer de nouvelles classes mais
avec une base existante.

class Voiture:
roues = 4 class VoitureSport(Voiture):
moteur = 1
def __init__(self): def __init__(self):
self.nom = "A déterminer" self.nom = "Ferrari"

la classe  VoitureSport a hérité de classe Voiture 

Elle récupère donc toutes ses méthodes et ses attributs.


L'héritage de classe — maFonction, maMethode pour
les fonctions et les méthodes ;
— MaClasse pour les classes ;
 On peut toujours instancier la classe Voiture si on le désire:

>>> ma_voiture= Voiture()

>>> ma_voiture.nom '


>>> ma_voiture.roues

On peut instancier maintenant la classe VoitureSport :

>>> ma_voiture_sport=VoitureSport()
>>> ma_voiture_sport.nom '
>>> ma_voiture_sport.roues

l'attribut roues a bien été hérité.


.
Quelques méthodes Python utiles

 Lorsqu’on crée une liste, un dictionnaire, une chaine de caractères, etc. on


crée avant tout un nouvel objet à partir des classes list, dict, str, etc.

https://www.pierre-giraud.com/python-apprendre-programmer-cours/top-methode/

Vous aimerez peut-être aussi