(Microsoft PowerPoint - Mise_Niveau01.ppt [Mode de compatibilit

Informatique Pour Tous
Informatique Pour Tous
I-Petite introduction
Qu’est ce que c’est Python ?
Python est un langage de programmation
multi-paradigme.
Historique :
Développé en 1989 par Guido van
Rossum.
En 2005, il a été engagé par Google
pour ne travailler que sur Python.
En décembre 2012, il quitte Google
pour rejoindre Dropbox à partir du 1er
janvier 2013
Caractéristiques :
¤ Libre et gratuit, multiplateforme ;
¤ Interprété (pas besoin de compilation) ;
¤ Peut être interactif (on peut s'en servir
comme une calculatrice) ;
¤ Impératif / Fonctionnel / Orienté Objet ;
¤ Extensible (par importation de modules
externes) ;
Pour pratiquer Python, il existe plusieurs interfaces graphiques
dont Pyzo :
Pour pratiquer Python, il existe plusieurs interfaces graphiques
dont Pyzo :
Console interactive pour taper des commandes en
direct. Les résultats des programmes s’y affichent.
Pour pratiquer Python, il existe plusieurs interfaces graphiques
dont Pyzo :
Éditeur pour écrire des
programmes
Pour pratiquer Python, il existe plusieurs interfaces graphiques
dont Pyzo :
D’autres fenêtres moins
immédiatement utiles
Informatique Pour Tous
I-Petite introduction
II-Concepts de base du langage
Informatique Pour Tous
I-Petite introduction
II-Concepts de base du langage
1) Types
Définition : dans un langage informatique,
un type est caractérisé par :
Définition : dans un langage informatique,
un type est caractérisé par :
¤ une manière de coder une information
en mémoire ;
Définition : dans un langage informatique,
un type est caractérisé par :
¤ une manière de coder une information
en mémoire ;
¤ un ensemble de propriétés utilisables
pour programmer dans ce langage.
Informatique Pour Tous
I-Petite introduction
II-Concepts de base du langage
1) Types
a) types numériques
En Python, il y a deux types pour les données
numériques, les entiers (integer) et les
nombres à virgule flottante (float).
En Python, il y a deux types pour les données
numériques, les entiers (integer) et les
nombres à virgule flottante (float).
Pour qu'une donnée numérique soit considérée
par Python comme étant du type float, il suffit
qu'elle contienne dans sa formulation un
élément tel qu'un point décimal ou un
exposant de 10.
Par exemple, les données :
3.14
10.
.001
1e100
3.14e-10
sont automatiquement interprétées par Python
comme étant du type float.
Les opérateurs utilisables sur ces données sont :
¤ l’addition en utilisant le symbole + ;
Les opérateurs utilisables sur ces données sont :
¤ l’addition en utilisant le symbole + ;
¤ la soustraction en utilisant le symbole − ;
Les opérateurs utilisables sur ces données sont :
¤ l’addition en utilisant le symbole + ;
¤ la soustraction en utilisant le symbole − ;
¤ la multiplication en utilisant le symbole * ;
Les opérateurs utilisables sur ces données sont :
¤ l’addition en utilisant le symbole + ;
¤ la soustraction en utilisant le symbole − ;
¤ la multiplication en utilisant le symbole * ;
¤ l’exponentiation en utilisant le symbole ** ;
On peut utiliser ces opérateurs avec des entiers
ou des flottants mais la précision peut être
moins bonne avec les flottants.
On peut faire une opération entre un flottant et
un entier mais elle s’effectue toujours en
flottant. L’entier mis en jeu est converti en
flottant « à la volée ».
…ET LA DIVISION ?
…ET LA DIVISION ?
On l’indique avec le symbole /. Elle donne
toujours un flottant, même si le reste est
nul.
…ET LA DIVISION ?
La division euclidienne se note //
et s’appelle division entière en
programmation.
Elle s’utilise avec des entiers
…ET LA DIVISION ?
La division euclidienne se note //
et s’appelle division entière en
programmation.
Elle s’utilise avec des entiers
…ET LA DIVISION ?
La division euclidienne se note //
et s’appelle division entière en
programmation.
Elle s’utilise avec des entiers
ou des flottants
…ET LA DIVISION ?
La division euclidienne se note //
et s’appelle division entière en
programmation.
Elle s’utilise avec des entiers
ou des flottants
et même des entiers négatifs
…ET LA DIVISION ?
Le reste de la division euclidienne peut
s’obtenir par l’opération notée % et
appelée modulo :
…ET LA DIVISION ?
Le reste de la division euclidienne peut
s’obtenir par l’opération notée % et
appelée modulo :
15 = [(−4) × (− 4)] − 1
En math on dira plutôt 15 = [(−4) × (− 3)] + 3
Remarque: il existe également le type
complex en Python.
On peut prendre le module :
On peut prendre le module :
la partie réelle et la
partie imaginaire ,
et le conjugué
!
On peut prendre le module :
la partie réelle et la
partie imaginaire ,
!
et le conjugué
real, imag et conjugate sont des méthodes
d’un objet de type complex
Informatique Pour Tous
I-Petite introduction
II-Concepts de base du langage
1) Types
a) types numériques
b) booléens
Les booléens sont un type spécial d’entiers qui ne peuvent
prendre que 2 valeurs :
¤ vrai, représentée par True (ou l’entier 1)
¤ faux, représentée par False (ou l’entier 0).
¤ aucune autre valeur ne peut représenter
True ou False
Les booléens permettent de représenter les résultats
d’expressions logiques qui peuvent prendre soit la valeur vraie,
soit la valeur fausse.
Remarque : il n’y a pas de peut-être en informatique booléenne.
Les opérateurs utilisables entre valeurs
booléennes sont :
¤ not
Les opérateurs utilisables entre valeurs
booléennes sont :
¤ not
¤ and
« x and y » renvoie False si x est
False, sinon renvoie l’évaluation de
y.
Les opérateurs utilisables entre valeurs
booléennes sont :
¤ not
¤ and
Cas particulier :
Dans ce cas, Python ne va pas évaluer y car il sait que
la partie gauche de l’expression and est False ce qui
implique que l’expression complète sera False quelles que
soient les autres valeurs. C’est ce que l’on appelle shortcircuit evaluation.
Par exemple, l’expression 2>3 and 3/0 renvoie FALSE
et non une erreur !
Les opérateurs utilisables entre valeurs
booléennes sont :
¤ not
¤ and
¤ or
Si x est True, « x or y » renvoie True,
sinon il renvoie l’évaluation de y.
(Short-circuit evaluation s’applique ici
aussi.)
On peut aussi utiliser des opérateurs de
comparaison (ils renvoient tous True ou False
et sont utilisés pour faire des tests).
Si les deux opérandes sont des nombres, ils
sont d’abord convertis en un type commun .
¤ == : compare deux objets pour voir s’ils ont
la même valeur.
¤ == : compare deux objets pour voir s’ils ont
la même valeur.
Les symboles sont
différents.
¤ == : compare deux objets pour voir s’ils ont
la même valeur.
Sa négation logique existe :
On préfère cette
notation
¤ == : compare deux objets pour voir s’ils ont
la même valeur.
¤ < : opérateur « strictement inférieur à »
¤ == : compare deux objets pour voir s’ils ont
la même valeur.
¤ < : opérateur « strictement inférieur à »
¤ > : opérateur « strictement supérieur à »
¤ == : compare deux objets pour voir s’ils ont
la même valeur.
¤ < : opérateur « strictement inférieur à »
¤ > : opérateur « strictement supérieur à »
¤ <= : opérateur « inférieur ou égal à »
¤ < : opérateur « strictement inférieur à »
¤ > : opérateur « strictement supérieur à »
¤ <= : opérateur « inférieur ou égal à »
¤ >= : opérateur « supérieur ou égal à »
¤ < : opérateur « strictement inférieur à »
¤ > : opérateur « strictement supérieur à »
¤ <= : opérateur « inférieur ou égal à »
L’ordre des symboles ne peut
pas être changé
¤ >= : opérateur « supérieur ou égal à »
Les comparaisons peuvent être chaînées
ou mélangées .
Les comparaisons peuvent être chaînées
ou mélangées .
Informatique Pour Tous
I-Petite introduction
II-Concepts de base du langage
1) Types
a) types numériques
b) booléens
c) collections
Python possède différents types de collections
ordonnées ou non d’objets variés .
Nous en utiliserons essentiellement 3.
a) Le type string (chaîne de caractères) est
une suite ordonnée quelconque de caractères
alphanumériques
(alphabet,
chiffres,
caractères spéciaux).
En Python, un objet de type string est défini
en le délimitant :
soit par des apostrophes (simple quotes),
soit par des guillemets (double quotes).
En Python, un objet de type string est défini
en le délimitant :
soit par des apostrophes (simple quotes),
soit par des guillemets (double quotes).
Pour commenter un programme (lignes
qui ne seront pas exécutées) on utilise :
¤ le caractère # au début d’une seule ligne ;
Pour commenter un programme (lignes
qui ne seront pas exécutées) on utilise :
¤ le caractère # au début d’une seule ligne ;
¤ les triples quotes de part et d’autres d’un
paragraphe .
Il faut utiliser la fonction
str() pour transtyper un
nombre (entier ou float) en
objet string.
Pour une chaîne qui contient plusieurs lignes,
on peut utiliser le caractère d’échappement \n
ou les triples quotes (utile pour commenter un
programme).
Le programme :
produit :
b) Le type tuple est une suite ordonnée non
modifiable d’objets quelconques (integer,
float, booléens, caractères, chaînes de
caractères, tuples, autres…)
Une objet de type tuple est construit en
utilisant une paire de parenthèses et des
virgules pour séparer les données :
(1,'a','mot',('ceci','est','un','tuple))
Une objet de type tuple est construit en
utilisant une paire de parenthèses et des
virgules pour séparer les données :
(1,'a','mot',('ceci','est','un','tuple'))
Un objet de ce type permet de stocker dans un
seul objet des données que l’on n’a pas besoin de modifier.
Un objet de ce type permet de stocker dans un
seul objet des données que l’on n’a pas besoin de modifier.
Exemple : pour stocker le nom, la taille, la date
de naissance et la possession du permis de
conduire pour un individu donné, on peut
créer l’objet suivant :
c) Le type list est une suite ordonnée
modifiable d’objets quelconques (integer,
float, booléens, caractères, chaînes de
caractères, tuples, list, autres…)
c) Le type list est une suite ordonnée
modifiable d’objets quelconques (integer,
float, booléens, caractères, chaînes de
caractères, tuples, list, autres…)
La liste et les objets qu’elle contient sont
modifiables sans créer un nouvel objet en
mémoire.
Mais ce type est moins performant qu’un
tuple pour le temps de création et l’occupation
mémoire. Il ne faut pas l’utiliser « par
défaut », si l’on sait que l’on n’aura pas à
modifier ses composants.
La construction d’une liste se fait en utilisant
des crochets à la place des parenthèses des
tuples.
d) manipulation d’une collection
string
tuple
list
définition
′…′′ ou ″…″″
(élém1, élém2,… )
[élém1, élém2,… ]
type des éléments
caractère
quelconque
quelconque
mutation
immutable
immutable
mutable
transtypage
int(mot) float(mot)
str(nombre);
str(tup)
tuple(mot)
str(lst)
tuple(mot)
string
tuple
list
définition
′…′′ ou ″…″″
(élém1, élém2,… )
[élém1, élém2,… ]
type des éléments
caractère
quelconque
quelconque
mutation
immutable
immutable
mutable
transtypage
int(mot) float(mot)
str(nombre);
str(tup)
tuple(mot)
str(lst)
tuple(mot)
nombre d’éléments
len(mot)
len(tup)
len(lst)
string
tuple
list
définition
′…′′ ou ″…″″
(élém1, élém2,… )
[élém1, élém2,… ]
type des éléments
caractère
quelconque
quelconque
mutation
immutable
immutable
mutable
transtypage
int(mot) float(mot)
str(nombre);
str(tup)
tuple(mot)
str(lst)
tuple(mot)
nombre d’éléments
len(mot)
len(tup)
len(lst)
vérification
d’appartenance d’un
élément
el in mot
sous_mot in mot
el in tup
el in lst
string
tuple
list
définition
′…′′ ou ″…″″
(élém1, élém2,… )
[élém1, élém2,… ]
type des éléments
caractère
quelconque
quelconque
mutation
immutable
immutable
mutable
transtypage
int(mot) float(mot)
str(nombre);
str(tup)
tuple(mot)
str(lst)
tuple(mot)
nombre d’éléments
len(mot)
len(tup)
len(lst)
vérification
d’appartenance d’un
élément
el in mot
sous_mot in mot
el in tup
el in lst
concaténation
mot1 + mot2
tup1 + tup2
lst1 + lst2
concaténation répétée
mot*n
tup*n
lst*n
string
tuple
list
accès à un élément
mot [i]
tup [i]
lst [i]
slicing
mot [i:j]
tup [i:j]
lst [i:j]
string
tuple
list
accès à un élément
mot [i]
tup [i]
lst [i]
slicing
mot [i:j]
tup [i:j]
lst [i:j]
01 2 3 45 6 7 8 9…
le dernier indice est j − 1, ici j = 6
donc on garde les caractères
d’indice 3, 4 et 5 .
string
tuple
list
accès à un élément
mot [i]
tup [i]
lst [i]
slicing
mot [i:j]
tup [i:j]
lst [i:j]
Remarque : en informatique, l’indice du premier
élément d’une collection est toujours zéro.
string
tuple
list
accès à un élément
mot [i]
tup [i]
lst [i]
slicing
mot [i:j]
tup [i:j]
lst [i:j]
Le slicing est très utile pour mettre en forme une collection
avant de l’utiliser.
string
tuple
list
accès à un élément
mot [i]
tup [i]
lst [i]
slicing
mot [i:j]
tup [i:j]
lst [i:j]
déconstruction
a, b, c = mot
a, b, c = tup
a, b, c = lst
(autant de variables que d’éléments)
string
tuple
list
accès à un élément
mot [i]
tup [i]
lst [i]
slicing
mot [i:j]
tup [i:j]
lst [i:j]
déconstruction
a, b, c = mot
a, b, c = tup
a, b, c = lst
mot.count(el)
tup.count(el)
lst.count(el)
(autant de variables que d’éléments)
nombre d’occurrences
d’un élément
string
tuple
list
accès à un élément
mot [i]
tup [i]
lst [i]
slicing
mot [i:j]
tup [i:j]
lst [i:j]
déconstruction
a, b, c = mot
a, b, c = tup
a, b, c = lst
mot.count(el)
tup.count(el)
lst.count(el)
(autant de variables que d’éléments)
nombre d’occurrences
d’un élément
.count() est un exemple de méthode des objets string, tuple et list.
mutation
string
tuple
list
immutable
immutable
mutable
assignation d’un élément
lst[i] = nouv_el
assignation de plusieurs
éléments
lst[i : j] = nouv_el
mutation
string
tuple
list
immutable
immutable
mutable
assignation d’un élément
lst[i] = nouv_el
assignation de plusieurs
éléments
lst[i : j] = nouv_el
Mais ce n’est pas possible avec un tuple ou une chaîne de caractères.
mutation
string
tuple
list
immutable
immutable
mutable
assignation d’un élément
lst[i] = nouv_el
assignation de plusieurs
éléments
lst[i : j] = nouv_el
mutation
string
tuple
list
immutable
immutable
mutable
assignation d’un élément
lst[i] = nouv_el
assignation de plusieurs
éléments
lst[i : j] = nouv_el
0
1
2
le dernier indice est j − 1, ici j = 3 .
mutation
string
tuple
list
immutable
immutable
mutable
assignation d’un élément
lst[i] = nouv_el
assignation de plusieurs
éléments
lst[i : j] = nouv_el
ajouter un élément en fin
de liste
lst.append(nouv_el)
mutation
string
tuple
list
immutable
immutable
mutable
assignation d’un élément
lst[i] = nouv_el
assignation de plusieurs
éléments
lst[i : j] = nouv_el
ajouter un élément en fin
de liste
lst.append(nouv_el)
Cette méthode est très utilisée pour construire une liste élément
par élément dans une boucle.
mutation
string
tuple
list
immutable
immutable
mutable
assignation d’un élément
lst[i] = nouv_el
assignation de plusieurs
éléments
lst[i : j] = nouv_el
ajouter un élément en fin
de liste
lst.append(nouv_el)
trier une liste
lst.sort()
mutation
string
tuple
list
immutable
immutable
mutable
assignation d’un élément
lst[i] = nouv_el
assignation de plusieurs
éléments
lst[i : j] = nouv_el
ajouter un élément en fin
de liste
lst.append(nouv_el)
trier une liste
lst.sort()
Il y a des parenthèses : c’est une fonction, même s’il n’y a
pas de paramètres
mutation
string
tuple
list
immutable
immutable
mutable
assignation d’un élément
lst[i] = nouv_el
assignation de plusieurs
éléments
lst[i : j] = nouv_el
ajouter un élément en fin
de liste
lst.append(nouv_el)
trier une liste
lst.sort()
ajouter un élément en
milieu de liste
lst.insert(i, nouv_el)
enlever un élément de la
liste et retourner cet
élément
lst.pop(i)
ajouter une liste en fin
de liste
lst.extend(autre_lst)
appariement de deux
listes
zip(lst1, lst2)
Informatique Pour Tous
I-Petite introduction
1) Objectifs
2) Le langage Python
II-Concepts de base du langage
1) Types
a) types numériques
b) booléens
c) collections
2) Outils de programmation
Informatique Pour Tous
I-Petite introduction
1) Objectifs
2) Le langage Python
II-Concepts de base du langage
1) Types
a) types numériques
b) booléens
c) collections
2) Outils de programmation
a) variable
En Python, toute valeur, fonction ou expression crée est un
objet
En Python, toute valeur, fonction ou expression crée est un
objet
qui occupe une place quelque part
dans la mémoire
En Python, toute valeur, fonction ou expression crée est un
objet
avec les propriétés et méthodes associées
au type de la valeur
Pour pouvoir réutiliser cet objet, il est indispensable de lui
donner un identifiant, appelé nom de variable.
En Python, les noms de variables obéissent à quelques
règles simples :
En Python, les noms de variables obéissent à 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.
En Python, les noms de variables obéissent à 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é).
En Python, les noms de variables obéissent à 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é).
¤ La casse est significative (les caractères
majuscules et minuscules sont distingués).
Exemple : Joseph, joseph, JOSEPH sont donc des variables
différentes.
Enfin, on ne peut pas utiliser comme noms de variables les 30
« mots réservés » qui sont utilisés par le langage lui-même.
and
del
for
is
raise
assert
elif
from
lambda
return
break
else
global
not
try
class
except
if
or
while
continue
exec
import
pass
yield
def
finally
in
print
Dans beaucoup de langages, la déclaration d’une variable
consiste à indiquer son nom et le type de la valeur qu’elle
référence.
Exemple en Visual Basic :
Dim
Dim
Dim
Dim
Dim
Dim
Dim
PremLigne As Integer, Ligne As Integer
AncienNum As Integer
Update As Boolean
DS_Num As Integer
Position As Long
PositionTotale As Long
Fin As String
Dans beaucoup de langages, la déclaration d’une variable
consiste à indiquer son nom et le type de la valeur qu’elle
référence.
Dans ce cas, la variable ne peut pas changer de type. Le
typage est dit statique (ou fort). C’est une méthode efficace
pour accélérer l’exécution.
L’affectation consiste alors à indiquer la valeur de la variable.
Dim Feuille As String
Dim Plage_Nom As String
Dim Plage_Ecrit As String
Dim Plage_Oral As String
Feuille = "Trim" + CStr(num)
Plage_Nom = "Nom_Trim" + CStr(num)
Plage_Ecrit = "Ecrit" + CStr(num)
Plage_Oral = "Oral" + CStr(num)
En Python, la déclaration et l'affectation sont confondues.
De plus, le typage est dynamique : une variable peut
référencer une autre valeur d’un autre type que celui de la
première pour laquelle elle a été définie.
En Python, la déclaration et l'affectation sont confondues.
Il en est de même en Maple :
Examinons une séquence d’instructions :
Python évalue l’expression
(5 * 3), en déduit le type
(int court) et crée en
mémoire la valeur (1510 en
binaire sur 32 bits).
Il donne ensuite un nom
(a) à l’étiquette.
Examinons une séquence d’instructions :
Il n’y a pas de résultat
affiché. C’était une
définition-affectation
Examinons une séquence d’instructions :
On peut demander la valeur
étiquetée par a
Examinons une séquence d’instructions :
et son adresse
Examinons une séquence d’instructions :
On définit un autre nom
pour la même étiquette
Examinons une séquence d’instructions :
Cela n’affiche pas de
résultat
mais b étiquette bien la
même valeur que a
Examinons une séquence d’instructions :
à la même adresse .
Examinons une séquence d’instructions :
On réaffecte a.
L’adresse de la valeur
n’est plus la même
Examinons une séquence d’instructions :
Mais b continue à
étiqueter la première
valeur
qui est toujours à
la même adresse
Examinons une séquence d’instructions :
Ceci est une expression
dont le résultat s’affiche aussitôt
Examinons une séquence d’instructions :
Ceci est une affectation
Examinons une séquence d’instructions :
On peut vérifier que
a
étiquette
de
nouveau la même
valeur que b.
Il est extrêmement important de ne pas confondre les
symboles :
=
qui désigne l’affectation d’une valeur à une
variable (en Maple, c’est le symbole :=) ;
== qui désigne l’opération vérifiant l’égalité de
deux valeurs (en Maple c’est le symbole =) .
Les opérateurs = et == font des choses différentes et ont
des propriétés différentes.
== est commutatif :
mais = ne l’est pas :
Conclusion : à gauche du signe =, on ne peut trouver
qu’un nom de variable.
Par contre, écrire a = a + 1 très fréquent en programmation
bien qu’inacceptable en mathématique.
Informatique Pour Tous
I-Petite introduction
II-Concepts de base du langage
1) Types
a) types numériques
b) booléens
c) collections
2) Outils de programmation
a) variable
b) contrôle de flux
Le langage Python est un langage impératif qui décrit
les opérations en termes de séquences d'instructions
exécutées dans l’ordre par l'ordinateur pour modifier l'état de
la mémoire.
Le « chemin » suivi par un programme est appelé un
flux d'exécution et les constructions qui le modifient sont
appelées des instructions de contrôle de flux.
Les structures de contrôle sont les groupes
d'instructions qui déterminent l'ordre dans lequel les actions
sont effectuées.
En programmation moderne, il en existe seulement trois :
Les structures de contrôle sont les groupes
d'instructions qui déterminent l'ordre dans lequel les actions
sont effectuées.
En programmation moderne, il en existe seulement trois :
¤ la séquence (ou bloc) : les instructions d'un bloc
s'exécutent les unes après les autres, dans l'ordre où elles ont
été écrites ;
Les structures de contrôle sont les groupes
d'instructions qui déterminent l'ordre dans lequel les actions
sont effectuées.
En programmation moderne, il en existe seulement trois :
¤ la séquence (ou bloc) : les instructions d'un bloc
s'exécutent les unes après les autres, dans l'ordre où elles ont
été écrites ;
¤ la sélection (ou test) : les instructions effectivement
exécutées dépendent d’une condition ;
Les structures de contrôle sont les groupes
d'instructions qui déterminent l'ordre dans lequel les actions
sont effectuées.
En programmation moderne, il en existe seulement trois :
¤ la séquence (ou bloc) : les instructions d'un bloc
s'exécutent les unes après les autres, dans l'ordre où elles ont
été écrites ;
¤ la sélection (ou test) : les instructions effectivement
exécutées dépendent d’une condition ;
¤ la répétition (ou boucle) : un bloc d’instructions est répété
plusieurs fois de manière identique. Elle peut être soumise à
une condition.
Ces structures de contrôles sont appelées instructions
composées (par opposition aux instructions simples comme
la déclaration ou l’affectation).
Ces structures de contrôles sont appelées instructions
composées (par opposition aux instructions simples comme
la déclaration ou l’affectation).
En Python, toutes 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.
ligne d'en-tête:
première instruction du bloc
... ...
... ...
dernière instruction du bloc
Un programme écrit en Python aura alors la structure
suivante :
instructions
…
ligne d’en-tête :
bloc 1
instructions
…
ligne d’en-tête :
instructions
…
ligne d’en-tête :
instructions
…
instructions
…
instruction composée
bloc 2
bloc 3
suite bloc 2
suite bloc 1
instruction composée
Test :
¤ En Python, le mot-clé est if suivi d’une expression dont
le résultat est un booléen ;
Test :
¤ En Python, le mot-clé est if suivi d’une expression dont
le résultat est un booléen ;
¤ La première instruction qui suit une instruction conditionnelle et qui est placée au même niveau d’indentation que
l’instruction if ne fait pas partie du bloc. Seules les instructions
indentées font partie du bloc ;
Test :
¤ En Python, le mot-clé est if suivi d’une expression dont
le résultat est un booléen ;
¤ La première instruction qui suit une instruction conditionnelle et qui est placée au même niveau d’indentation que
l’instruction if ne fait pas partie du bloc. Seules les instructions
indentées font partie du bloc ;
¤ En cas de if au sein d’un if (test imbriqué), le second bloc
doit avoir un niveau d’indentation supérieur.
Test :
¤ En Python, le mot-clé est if suivi d’une expression dont
le résultat est un booléen ;
¤ La première instruction qui suit une instruction conditionnelle et qui est placée au même niveau d’indentation que
l’instruction if ne fait pas partie du bloc. Seules les instructions
indentées font partie du bloc ;
¤ En cas de if au sein d’un if (test imbriqué), le second bloc
doit avoir un niveau d’indentation supérieur.
Par exemple :
if x != 0:
y = x * x
if y % 2 == 0:
y = y + 1
x = x + y
x = x * y
exécutée si x != 0 est
vrai
exécutée si x != 0 est vrai
Test :
¤ En Python, le mot-clé est if suivi d’une expression dont
le résultat est un booléen ;
¤ La première instruction qui suit une instruction conditionnelle et qui est placée au même niveau d’indentation que
l’instruction if ne fait pas partie du bloc. Seules les instructions
indentées font partie du bloc ;
¤ En cas de if au sein d’un if (test imbriqué), le second bloc
doit avoir un niveau d’indentation supérieur.
Par exemple :
if x != 0:
y = x * x
if y % 2 == 0:
y = y + 1
x = x + y
x = x * y
exécutée si x != 0 est vrai ET SI
y % 2 == 0 est vrai
Test :
¤ En Python, le mot-clé est if suivi d’une expression dont
le résultat est un booléen ;
¤ La première instruction qui suit une instruction conditionnelle et qui est placée au même niveau d’indentation que
l’instruction if ne fait pas partie du bloc. Seules les instructions
indentées font partie du bloc ;
¤ En cas de if au sein d’un if (test imbriqué), le second bloc
doit avoir un niveau d’indentation supérieur.
Par exemple :
if x != 0:
y = x * x
if y % 2 == 0:
y = y + 1
x = x + y
x = x * y
toujours exécutée
Test :
¤ S’il y a deux blocs d’instruction à exécuter suivant la valeur
de l’expression test, on utilise l’entête else : au même niveau
d’indentation que le if ;
Test :
¤ S’il y a deux blocs d’instruction à exécuter suivant la valeur
de l’expression test, on utilise l’entête else : au même niveau
d’indentation que le if ;
Par exemple :
if x
y
else
y
!= 0:
= 3 / x
:
= 5000
exécutée si x != 0 est vrai
exécutée si x != 0 est faux
Test :
¤ S’il y a deux blocs d’instruction à exécuter suivant la valeur
de l’expression test, on utilise l’entête else : au même niveau
d’indentation que le if ;
¤ S’il y a plus de deux expressions à tester, chaque nouvelle
expression est incluse dans un entête elif…(expression) :
Idéalement, ces conditions sont mutuellement
exclusives et la dernière peut donc être ignorée puisqu’elle est
équivalente à la négation de toutes les autres.
Test :
¤ S’il y a deux blocs d’instruction à exécuter suivant la valeur
de l’expression test, on utilise l’entête else : au même niveau
d’indentation que le if ;
¤ S’il y a plus de deux expressions à tester, chaque nouvelle
expression est incluse dans un entête elif…(expression) :
Idéalement, ces conditions sont mutuellement exclusives et la
dernière peut donc être ignorée puisqu’elle est équivalente à la
Par exemple :
négation de toutes les autres.
if x
y
elif
y
else
y
>
=
x
=
:
=
0:
3 / x
< 0:
- 3 / x
1
Boucle inconditionnelle :
¤ En Python, le mot-clé est for suivi d’une instruction
utilisant l’opérateur in ;
Par exemple :
cryptage = ' '
for lettre in 'Maple' :
marque d’en tête
collection itérable (chaîne de caractères, tuple, liste…)
variable de boucle
Boucle inconditionnelle :
¤ En Python, le mot-clé est for suivi d’une instruction
utilisant l’opérateur in ;
Par exemple :
cryptage = ' '
for lettre in 'Maple' :
code = ord(lettre)
car = chr(code + 7)
cryptage += car
Boucle inconditionnelle :
¤ En Python, le mot-clé est for suivi d’une instruction
utilisant l’opérateur in ;
Par exemple :
cryptage = ' '
for lettre in 'Maple' :
code = ord(lettre)
car = chr(code + 7)
cryptage += car
crée la chaîne cryptage = 'Thwsl'
Boucle inconditionnelle :
¤ En Python, le mot-clé est for suivi d’une instruction
utilisant l’opérateur in ;
¤ Si la variable de boucle est un entier, la collection
itérable (domaine des valeurs de la variable) est crée par la
fonction range().
Boucle inconditionnelle :
¤ En Python, le mot-clé est for suivi d’une instruction
utilisant l’opérateur in ;
¤ Si la variable de boucle est un entier, la collection
itérable (domaine des valeurs de la variable) est crée par la
fonction range().
Paramètres de cette fonction : range(début, fin , pas)
premier entier crée (valeur 0 par
défaut, qui peut être omise)
Boucle inconditionnelle :
¤ En Python, le mot-clé est for suivi d’une instruction
utilisant l’opérateur in ;
¤ Si la variable de boucle est un entier, la collection
itérable (domaine des valeurs de la variable) est crée par la
fonction range().
Paramètres de cette fonction : range(début, fin , pas)
premier entier crée (valeur 0 par
défaut, qui peut être omise)
dernier entier crée (cette valeur est
non comprise)
Boucle inconditionnelle :
¤ En Python, le mot-clé est for suivi d’une instruction
utilisant l’opérateur in ;
¤ Si la variable de boucle est un entier, la collection
itérable (domaine des valeurs de la variable) est crée par la
fonction range().
Paramètres de cette fonction : range(début, fin , pas)
premier entier crée (valeur 0 par
défaut, qui peut être omise)
dernier entier crée (cette valeur est
non comprise)
écart entre 2 entiers (valeur 1 par
défaut, qui peut être omise)
Boucle inconditionnelle :
¤ En Python, le mot-clé est for suivi d’une instruction
utilisant l’opérateur in ;
¤ Si la variable de boucle est un entier, la collection
itérable (domaine des valeurs de la variable) est crée par la
fonction range().
Par exemple, range(2, 19, 3) crée la collection d’entiers
(2, 5, 8, 11, 14, 17)
et range(19, 2, −3)
(19, 16, 13, 10, 7, 4)
Boucle inconditionnelle :
¤ En Python, le mot-clé est for suivi d’une instruction
utilisant l’opérateur in ;
¤ Si la variable de boucle est un entier, la collection
itérable (domaine des valeurs de la variable) est crée par la
fonction range().
Par exemple, range(2, 19, 3) crée la collection d’entiers
(2, 5, 8, 11, 14, 17)
et range(19, 2, −3)
(19, 16, 13, 10, 7, 4)
Comment obtenir (5, 4, 3, 2, 1, 0) ?
Boucle inconditionnelle :
¤ En Python, le mot-clé est for suivi d’une instruction
utilisant l’opérateur in ;
¤ Si la variable de boucle est un entier, la collection
itérable (domaine des valeurs de la variable) est crée par la
fonction range().
Par exemple, range(2, 19, 3) crée la collection d’entiers
(2, 5, 8, 11, 14, 17)
et range(19, 2, −3)
(19, 16, 13, 10, 7, 4)
Comment obtenir (5, 4, 3, 2, 1, 0) ?
range(5, − 1, − 1)
Boucle inconditionnelle :
Dans l’exemple vu précédemment, l’en tête
for lettre in 'Maple' :
peut être remplacée par
for i in range(len('Maple')) :
car = 'Maple'[i]
…..
Boucle conditionnelle :
¤ En Python, le mot-clé est while suivi d’une instruction
dont le résultat est un booléen ;
Le programme précédent devient :
while i < len('Maple') :
car = 'Maple'[i]
i=i+1
….
Il faut incrémenter la variable
de boucle « à la main » car while
ne le fait pas automatiquement au
contraire de for.
Boucle conditionnelle :
¤ En Python, le mot-clé est while suivi d’une instruction
dont le résultat est un booléen ;
Le programme précédent devient :
while i < len('Maple') :
car = 'Maple'[i]
i=i+1
….
Il faut incrémenter la variable
de boucle « à la main » car while
ne le fait pas automatiquement au
contraire de for.
Quelque soit la variable de boucle, elle doit être modifiée
dans la boucle pour que la valeur du booléen change après un
certain nombre d’itérations et que la boucle ne soit pas infinie.
Informatique Pour Tous
I-Petite introduction
II-Concepts de base du langage
1) Types
a) types numériques
b) booléens
c) collections
2) Outils de programmation
a) variable
b) contrôle de flux
c) fonction
Une fonction est un bloc de code réutilisable qui sert à
exécuter une action simple. Les fonctions permettent une
grande modularité du programme et un haut degré de
réutilisation du code.
Une fonction est un bloc de code réutilisable qui sert à
exécuter une action simple. Les fonctions permettent une
grande modularité du programme et un haut degré de
réutilisation du code.
Python contient déjà beaucoup de fonctions intégrées mais
l’utilisateur peut aussi créer ses propres fonctions.
Parmi les fonctions intégrées de Python, il existe des
fonctions d’interface très utiles.
Parmi les fonctions intégrées de Python, il existe des
fonctions d’interface très utiles.
¤ input(‘un_texte_d_invitation’)
Cette fonction provoque une interruption dans le
programme courant. L'utilisateur est invité à entrer des
caractères au clavier et à terminer avec <Enter>.
Parmi les fonctions intégrées de Python, il existe des
fonctions d’interface très utiles.
¤ input(‘un_texte_d_invitation’)
Cette fonction provoque une interruption dans le
programme courant. L'utilisateur est invité à entrer des
caractères au clavier et à terminer avec <Enter>.
Lorsque cette touche est enfoncée, l'exécution du
programme se poursuit, et la fonction fournit en retour une
chaîne de caractères correspondant à ce que l'utilisateur a
entré. Cette chaîne peut alors être assignée à une variable
quelconque, convertie, etc.
Parmi les fonctions intégrées de Python, il existe des
fonctions d’interface très utiles.
¤ print(valeurs1, valeur2, …)
Cette fonction permet d'afficher à l’écran (dans la console
interactive) n'importe quel nombre de valeurs fournies en
arguments (c'est-à-dire entre les parenthèses), séparées par une
virgule .
Parmi les fonctions intégrées de Python, il existe des
fonctions d’interface très utiles.
¤ print(valeurs1, valeur2, …)
Cette fonction permet d'afficher à l’écran (dans la console
interactive) n'importe quel nombre de valeurs fournies en
arguments (c'est-à-dire entre les parenthèses), séparées par une
virgule .
Par défaut, ces valeurs apparaîtront séparées les unes des
autres par un espace et le tout se terminera par un saut à la
ligne.
Les fonctions définies par l’utilisateur :
On les définit avec une en-tête du type :
def nom_fonction(param1, param2,…) :
mot clé def indispensable
Les fonctions définies par l’utilisateur :
On les définit avec une en-tête du type :
def nom_fonction(param1, param2,…) :
mot clé def indispensable
nom de la fonction (suit les mêmes règles que les
noms de variable)
Les fonctions définies par l’utilisateur :
On les définit avec une en-tête du type :
def nom_fonction(param1, param2,…) :
mot clé def indispensable
nom de la fonction (suit les mêmes règles que les
noms de variable
variables utilisées dans la fonction dont la valeur
sera donnée dans l’appel de la fonction. Le
nombre de paramètres peut être nul.
Les fonctions définies par l’utilisateur :
On les définit avec une en-tête du type :
def nom_fonction(param1, param2,…) :
instruction 1
bloc d’instructions indenté
instruction 2
réalisant l’action prévue pour
….
cette fonction ; il peut contenir
des tests ou des boucles
Les fonctions définies par l’utilisateur :
On les définit avec une en-tête du type :
def nom_fonction(param1, param2,…) :
instruction 1
instruction 2
….
return resultat
le mot clé return indique la
valeur renvoyée par la
fonction.
Les fonctions définies par l’utilisateur :
On les définit avec une en-tête du type :
def nom_fonction(param1, param2,…) :
instruction 1
instruction 2
….
return resultat
le mot clé return indique la
valeur renvoyée par la
fonction.
Il n’y a qu’une valeur
retournée mais cela peut être
un tuple.
Les fonctions définies par l’utilisateur :
On les définit avec une en-tête du type :
def nom_fonction(param1, param2,…) :
instruction 1
instruction 2
if ….. :
La fonction peut contenir
return resultat1 plusieurs return mais elle se
else :
ferme dès qu’un premier
return resultat2 return a été exécuté.
Les fonctions définies par l’utilisateur :
On les définit avec une en-tête du type :
def nom_fonction(param1, param2,…) :
instruction 1
instruction 2
La fonction
peut ne pas
contenir de return. Elle
modifie l’état de la mémoire
sans renvoyer de valeur à
utiliser.
Elle serait appelée procédure
dans un autre langage
Les fonctions définies par l’utilisateur :
On les définit avec une en-tête du type :
def nom_fonction(param1, param2,…) :
instruction 1
instruction 2
Les fonctions ou procédures doivent toujours être
définies avant d'y faire appel sinon l’interpréteur indiquera
que la fonction n'est pas définie.
Les fonctions définies par l’utilisateur :
On les définit avec une en-tête du type :
def nom_fonction(param1, param2,…) :
instruction 1
instruction 2
Les fonctions ou procédures doivent toujours être
définies avant d'y faire appel sinon l’interpréteur indiquera
que la fonction n'est pas définie.
Un appel à une fonction se fait simplement par son nom,
avec un nombre de variables correspondant au nombre de
paramètres :
resultat = nom_fonction(var1, var2, …)
Informatique Pour Tous
I-Petite introduction
II-Concepts de base du langage
1) Types
a) types numériques
b) booléens
c) collections
2) Outils de programmation
a) variable
b) contrôle de flux
c) fonction
d) bibliothèque
Caractéristiques du langage Python :
¤ Libre et gratuit, multiplateforme ;
¤ Interprété (pas besoin de compilation) ;
¤ Peut être interactif (on peut s'en servir
comme une calculatrice) ;
¤ Impératif / Fonctionnel / Orienté Objet ;
¤ Extensible (par importation de modules
externes) ;
Pour utiliser les fonctions contenues dans
bibliothèque extérieur, il y a trois syntaxes possibles :
une
Pour utiliser les fonctions contenues dans
bibliothèque extérieur, il y a trois syntaxes possibles :
¤ import nom_module
une
Pour utiliser les fonctions contenues dans
bibliothèque extérieur, il y a trois syntaxes possibles :
une
¤ import nom_module
On importe ainsi dans la mémoire l’objet nom_module
dont on veut utiliser les méthodes .
On appelle ensuite une fonction par
nom_module.nom_fonction()
Pour utiliser les fonctions contenues dans
bibliothèque extérieur, il y a trois syntaxes possibles :
une
¤ import nom_module
On importe ainsi dans la mémoire l’objet nom_module
dont on veut utiliser les méthodes .
On appelle ensuite une fonction par
nom_module.nom_fonction()
Pour alléger l’écriture, on peut donner un surnom à la
bibliothèque :
import nom_module as nm
nm.nom_fonction()
Pour utiliser les fonctions contenues dans
bibliothèque extérieur, il y a trois syntaxes possibles :
une
¤ import nom_module
¤ from nom_module import *
On importe ainsi dans la mémoire toutes les fonctions de la
bibliothèque d’un seul coup.
On appelle ensuite chaque fonction par
nom_fonction()
Pour utiliser les fonctions contenues dans
bibliothèque extérieur, il y a trois syntaxes possibles :
une
¤ import nom_module
¤ from nom_module import *
On importe ainsi dans la mémoire toutes les fonctions de la
bibliothèque d’un seul coup.
On appelle ensuite chaque fonction par
nom_fonction()
C’est plus léger à écrire mais cela prend plus de place en
mémoire.
Pour utiliser les fonctions contenues dans
bibliothèque extérieur, il y a trois syntaxes possibles :
une
¤ import nom_module
¤ from nom_module import *
¤ from nom_module import nom_fonction
On importe ainsi dans la mémoire la seule fonction dont on
veut se servir.
On appelle ensuite la fonction par
nom_fonction()
C’est léger à écrire et ne prend pas trop de place en
mémoire. C’est la méthode à privilégier quand on veut utiliser
peu de fonctions de la bibliothèque.
Les modules que vous utiliserez ici sont essentiellement :
¤ math (pour les fonctions mathématiques de base) ;
¤ numpy (idem et encore plus de fonctionnalités
mathématiques) ;
¤ matplotlib.pyplot (pour les représentations graphiques)
Il en existe beaucoup d’autres.
def message(chaine):
texte = ''
for i in range(10) :
texte += chaine +'\n'
return texte
avis = message("Au boulot !")
print(avis)
exercice 1
année bissextile
Une année est bissextile si son millésime est divisible par 4
mais pas par 100 ou s’il est divisible par 400.
Écrire le bloc d’instructions qui demande d’entrer une année et
affiche si l’année a est bissextile ou pas.
* version 1 : en utilisant uniquement des tests simples,
sans opérateurs and et or.
* version 2 : en utilisant un seul test, avec les opérateurs
and et or.
exercice 2
recherche d’un élément dans une liste d’éléments non triée :
Écrire une fonction qui renvoie True ou False selon qu’un
élément el donné appartient à une liste (ou un tuple) lst
donnée.
version 1 : en utilisant range() comme itérable ;
version 2 : en utilisant la liste elle-même comme itérable ;
variantes possibles :
¤ la fonction renvoie l’indice de el dans la liste ;
¤ la fonction renvoie tous les indices de el dans la
liste en cas d’occurrences multiples.
exercice 3
recherche du maximum dans une liste de nombres :
Écrire une fonction qui renvoie la valeur et l’indice du
maximum d’une liste (ou un tuple) lst d’entiers donnée.
Démontrer la correction de l’algorithme.
Variante : même question pour le minimum de la liste.
exercice 4
calcul de la moyenne et de la variance d’une liste de
nombres :
Rappel des définitions statistiques pour une liste de n valeurs :
valeur moyenne
1 n
X = ∑ Xi
n i =1
variance
1 n
V ( X ) = ∑ Xi − X
n i =1
(
)
2
écart-type
estimateur de σ
σ = V (X )
1 k << n
s( X ) =
∑ Xi − X
k − 1 i =1
(
)
2
Écrire une fonction qui renvoie la valeur de la moyenne et
la variance d’une liste (ou un tuple) lst d’entiers donnée.
1 n
V ( X ) = ∑ Xi − X
n i =1
2
2
1 n

=  ∑ X i2  − X
 n i =1

Montrer le théorème
(
)
et l’utiliser dans une autre fonction de calcul de la variance.