Introduction à Python NSI

Bases de programmation Cours/TD

1 Introduction - Vocabulaire
a) "reçoit" vs "égal", "égal" vs "égal égal"
x=5 n’a pas le même sens (en python) que x == 5 et ce n’est pas symétrique

b) "paramètre" vs "argument"
def nom_fonction(a,b) : # paramètres
... corps de la fonction

x = nom_fonction(x,y) # arguments

Différencier les paramètres qui sont dans la définition, des arguments qui sont utilisés à l’appel

c) "définition" de fonction et "appel" de fonction

# DEFINITION
def nom_fonction(a,b) :
... corps de la fonction

# APPEL
x = nom_fonction(x,y)

Bien identifier que la définition est une façon de stocker "pour plus tard" l’aspect référence de l’appel

d) Erreur de "compilation" (interprétation) vs erreur d’exécution vs conception

if x!= 0 # oubli du ":"
print(z/x)

et
print(z/x) # si x est nul

ne provoquent pas la même erreur ("invalid syntax" vs "division by zero")

Différencier les types d’erreur pour mieux corriger

e) Conseil :

L’ordinateur est bête... il ne ment jamais... Ne pas en douter !

Bases de python – Introduction – page 1 | 10

2 Python basique

2.1 - Variables, (non) typage et entrées/sortie

Qu’est-ce qu’une variable ?
x=5
y = "abc"
z = 5 + 12
➢ un identifiant, le nom de la variable. CHOIX PRIMORDIAL. Eviter les accents (encodage dif-
férent selon outils, systèmes...)
➢ un contenant, la case mémoire "physique"
➢ un contenu, la valeur
➢ un type, le domaine. En résumé les opérations qu’on peut utiliser sur cette variable

Analogie avec des boîtes aux lettres (destinataire, boîte aux lettres, courrier, genre de cour-
rier que peut contenir la boîte). Ou pots de peinture (nom de la couleur, pot de peinture,
quantité de peinture restante et couleur, genre de peinture que peut contenir le pot).

Particularité en python
➢ Pas de déclaration
➢ Typage inféré (deviné par python)
➢ Pas de persistance de type
x=5
print(type(x)) # va repondre int
x = "abc" # aucun probleme
print(type(x)) # va repondre str

Types scalaires standards

➢ int : entier
➢ float : nombre réel (opérations compatibles avec int, conversion vers le plus général si be-
soin)
➢ bool : booléen (True ou False)
➢ str : chaîne de caractères
x=3
y = 22.4
x=x+y
print(x)
# affiche 25.4

Lien vers tableau des opérateurs et priorités python

Opérations entières à noter

➢ // pour la division entière
➢ % pour le modulo (reste de la division entière)

Bizarreries python

Quand c’est "interprétable", python interprète...

mot = "a" *3 # mot reçoit "aaa"

Bases de python – Introduction – page 2 | 10

Affectation multiple
x, y = 4, "abc" # deux affectations simultanées

x, y = y , x # échange de variables

Extrêmement pratique et utilisé (notamment pour les retours de fonctions).

Entrées
x=input() # minimaliste , toujours str

x = int(input()) # conversion en int

x = float(input()) # conversion en float

x = int(input("saisissez un entier")) # avec message "intégré"

Sorties
x = "123"
print(x) # affiche 123 puis saut de ligne
y = "45"
print(x,y) # affiche 123 45 puis saut de ligne
print(x,y,sep="...") # affiche 123...45 puis saut de ligne
print("abc" + x) # affiche abc123 puis saut de ligne
print("123", end="") # pas de saut de ligne

2.2 - Structures de contrôle

3 structures de contrôle
➢ Séquence
➢ Sélection
➢ Répétition
Et ça suffit pour TOUT programmer.... ! ! !

a) Séquence
Une suite finie d’actions (action1, action2, ..., actionn) qui s’exécutent d’une façon inconditionnelle.
La syntaxe (PAS DE " ;") :
action 1
action 2
action 3

Se lit "exécuter action 1, puis action 2, puis action 3"

exemple :
x = int(input("x?"))
y=x+2
print(x + y)

Bases de python – Introduction – page 3 | 10

 Pas à pas... représentation (trace ou tableau de situation) :

b) Sélection
La sélection permet de choisir une action en fonction d’une condition :
if <condition> :
<code >
Se lit "si condition s’évalue à vrai (True) alors exécuter code"
if <condition> :
<code1>
else :
<code2>
Se lit "si condition s’évalue à vrai (True) alors exécuter code1, sinon (condition qui s’évalue à False)
exécuter code 2.
L’indentation sert de séparateur de bloc (begin...end ou {}) if et else sont des mots clés réservés de py-
thon.

Les opérateurs booléens sont :

== != < <= > >= or and not
Exemple de <condition> :
if x>0 :
if x>0 and y<0 :
if fonction(x,y,2+z)+7==28 :
...
On peut aussi ajouter elif, le "sinon si" :
if <condition1> :
<code1>
elif <condition2> :
<code2>
else : #facultatif
<code3>

Bases de python – Introduction – page 4 | 10

 exemple :
x = int(input("x?"))
if x>0 :
print(x, "est strictement positif")
elif x<0 :
print(x, "est strictement négatif")
else :
print(x, "est nul")

Pas à pas... représentation :

c) Répétition while
C’est une structure de contrôle qui permet de répéter un bloc d’instructions tant qu’une condition est
vraie.
while <condition> :
<code >
Se lit "tant que condition s’évalue à vrai (True) exécuter code".
➢ Chaque exécution du bloc code est une itération.
➢ condition est une expression logique (booléenne). Cette condition doit avoir une valeur avant
d’arriver au while.
➢ code représente le traitement à répéter et doit modifier la condition pour espérer terminer (er-
reur de conception).
➢ while est un mot clé réservé de python.

Les 3 "essentiels" d’une boucle while

➢ Initialisation
➢ Condition
➢ Modification (des variables concernées par la condition)
ATTENTION ! ! !

Bases de python – Introduction – page 5 | 10

 Méthodologie : comment procéder ?
➢ Mauvaise méthode : se jeter sur le clavier, écrire un code erroné, le corriger, le corriger, le
corriger,...
➢ Approche
 Quelle est l’idée générale de l’algorithme ?
 C’est ce qu’on appelle le modèle de solution
 Pour le réaliser, se poser les questions :
 Corps de la boucle : Quel est le schéma répétitif ?
 Condition de la boucle : A quoi veut-on aboutir ?
 Modification : Comment passer "au suivant" ?
 Initialisation : Comment démarrer ?
Conseil :
➢ mettre la/les instructions de modification en fin de boucle.

Exemples :
#somme des entiers tant que entier saisi non nul
#quantité d’itérations inconnue (introduire un booléen ?)
x = int(input("x?"))
somme = 0
while x>0 :
somme = somme + x
x = int(input("x?"))
print(somme)

#somme de n entiers saisis, n donné au début

#quantité d’itérations connue
n = int(input("n?"))
somme = 0
while n>0 :
x = int(input("x?"))
somme = somme + x
n=n-1
print(somme)

d) Répétition for
C’est une structure de contrôle qui permet de répéter un bloc d’instructions autant de fois que préci-
sé.
for <variable> in range(<depart>,<fin_exclu>):
<code>
Se lit "pour toutes valeurs de variable dans l’intervalle [depart, fin_exclu[, exécuter successivement
le code".
➢ variable va prendre initialement la valeur de l’indice de départ puis incrémenter de 1
➢ si on ne précise pas, l’indice de départ est 0
➢ la partie < code > de la boucle for va être exécutée pour chacune des valeurs
Il faut être sûr de vouloir exécuter fin_exclu − depart fois le code, sinon il est plus judicieux d’utiliser
un while avec une condition qui permette d’arrêter la boucle avant la fin.

Bases de python – Introduction – page 6 | 10

 Les 3 "essentiels" d’une boucle for
Ils sont cachés, mais existent bel et bien !
➢ Initialisation : la variable est initialisé à la valeur depart
➢ Condition : tant que la variable est inférieure (stricte) à fin_exclu
➢ Incrémentation : de manière "masquée", la valeur de variable prendra (systématiquement) la
valeur prévue de l’itération.

Bonnes habitudes
➢ INTERDIRE DE MODIFIER variable dans le code
➢ break à bannir (autant faire une while)
➢ nommer variable i souvent pratique, rajouter un ptit mot derrière ijour (pour un ième numéro
de jour) ou inom (pour un ième nom)...
Un for peut toujours s’écrire avec un while, mais pas l’inverse !

Exemples :
#exemple précédent
#somme de n entiers saisis, n donné au début
n = int(input("n?"))
somme = 0
while n>0 :
x = int(input("x?"))
somme = somme + x
n=n-1
print(somme)

#somme de n entiers saisis, n donné au début

n = int(input("n?"))
somme = 0
for i in range(0,n) :
x = int(input("x?"))
somme = somme + x
print(somme)

3 Fonctions
Pourquoi créer des fonctions ?
➢ Ré-utiliser
➢ Généraliser
➢ Améliorer

Syntaxe DEFINITION
def <nom>(<param1,param2,... paramN>):
<instructions>
Se lit "on définit la fonction nom ayant les paramètres param1, param2... param N qui va exécuter
les instructions".
Les valeurs des paramètres ne seront connues qu’à l’appel de la fonction.
On écrit donc quelque chose de "généraliste". On peut dire "pour toutes valeurs de param1, de pa-
ram2..."...
On appelle corps les instructions de la fonction.

Bases de python – Introduction – page 7 | 10

Description
def f(x):
’’’ description de f’’’
return x

help(f) #comme pour toute fonction ou type ou class de python

Help on function f in module __main__:
f(x)
description de f

➢ Intérêt de la description : avoir une aide automatique pour chaque fonction avec l’instruction
help(<nom>)
➢ Description simple qui mentionne l’objectif de la fonction, les paramètres et leur rôle
➢ Retour d’expérience de la description : échec car "trop" exigent et peu intéressant sur petits
programmes.

Syntaxe APPEL
...
<nom>(<arg1,arg2,...,argN>)
...

Se lit "on appelle la fonction nom avec les valeurs des arguments arg1, arg2, ... argN".
Les instructions du corps de la fonction seront exécutées en remplaçant les paramètres par les va-
leurs des arguments correspondants.

Le return
➢ Si la fonction doit produire une valeur, return va permettre de sortir de la fonction, et rempla-
cer l’appel de fonction par la valeur retournée. C’est la majorité des cas, sinon c’est souvent
de l’affichage ou de la mise à jour de type complexe.
➢ S’il n’y a pas de return la fonction se termine après la dernière instruction (et renvoie None).
➢ Il est possible d’avoir plusieurs return dans une fonction, le premier rencontré sort définitive-
ment, mais ce qui est "après" ne sera jamais exécuté.

Paramètres/Arguments
➢ Paramètres/nom de fonction : choisir des noms courts et explicites (sans accent), il y a des
règles de nommage.
➢ A l’appel, fournir un argument pour chaque paramètre. Un argument peut être une valeur,
une variable, une expression qui est évaluée pour être ainsi affectée au paramètre corres-
pondant de la fonction.
➢ le passage par paramètre peut être vu comme une affectation
➢ les paramètres et les arguments sont indépendants : si la fonction modifie un paramètre, elle
ne modifie pas l’argument correspondant
➢ les variables et paramètres de la fonction sont définis (et existent) uniquement pour l’exécu-
tion de la fonction, on les appelle des variables locales à la fonction. Elles n’ont pas d’exis-
tence en dehors de l’exécution de la fonction.
➢ Remarque : s’il n’y a pas de paramètres, l’appel se fait avec des parenthèses vides :
def fonction_sans_param(): ...

Bases de python – Introduction – page 8 | 10

 Exemple :
def addition(a,b) :
return a + b
x = int(input("x?"))
y = int(input("y?"))
resultat = addition(x,y)
print(resultat)

Pas à pas... représentation :

Composition
On peut composer les appels de fonctions
#definition de la fonction
def minimum(a,b):
"""Minimum de deux nombres a et b"""
# calcul
if (a<b):
min=a
else:
min=b
return min
#exemple d’appel
print(minimum(5,6))
print(minimum(4,minimum(1,6)))

Bases de python – Introduction – page 9 | 10

Comportement variables, paramètres, arguments
Quelques exercices ?
def fonction_z1(a):
a=8
return 7

x = 20
y = fonction_z1(x)
print(x)
####
def fonction_z2(a):
b=8
return 7

b = 20
y = fonction_z2(b)
print(b)
####
a=10
def fonction_z3(a,b):
return a+b

a=3
a=fonction_z3(a,5)
print(a)

Bases de python – Introduction – page 10 | 10