Aller au contenu

Initiation à Python

Découverte de la console

Ouvrir la console dans un nouvel onglet

Dans la console, on peut taper des instructions Python après les trois chevrons >>>. Les instructions s’exécutent lorsqu'on tape sur Enter.
On peut écrire une suite d’instructions en les séparant par un ;. Le dernier résultat peut être rappelé avec _.

Opérations mathématiques

  • Les quatre opérations usuelles s’obtiennent avec les symboles +, -, *,/.
  • Le quotient d’une division euclidienne est obtenu avec le symbole // , et le reste avec %.
  • L’exponentiation (puissance) s’obtient avec **.
  • Les ordres de priorité sont les mêmes qu’en mathématiques et si besoin on peut utiliser des ( ).
  • Selon les bonnes pratiques, les opérateurs suivants (+, -, *, /) sont à entourer en règle générale d'un espace avant et d'un espace après l'opérateur. Lorsqu'une expression comporte des opérations de différentes priorités, on peut réserver les espaces à l'opérateur de plus faible priorité.

Anticiper le résultat de l'exécution de chaque instruction dans la console et vérifier le résultat affiché.

>>> 3 + 5
>>> 2 + 3 * 5
>>> 23 / 4
>>> 23 // 4
>>> 23 % 4
>>> 2**3

Variables

L’affectation d’une valeur à une variable se fait à l’aide du symbole =, symbole non symétrique ici. Selon les recommandations, le nom d'une variable peut contenir des lettres minuscules et le tiret bas. Les noms explicites sont à privilégier.
Lors de l'affectation d'une valeur à une variable :

nom_variable = expression
l'expression de droite est évaluée et sa valeur est affectée à la variable.

L’affichage de la valeur référencée par une variable peut se faire dans la console en écrivant simplement le nom de la variable (si cette instruction est la dernière avant exécution), ou en utilisant la fonction print().

Anticiper le résultat de l'exécution de chaque instruction dans la console et vérifier le résultat affiché.

>>> a = 3
>>> b = a + 2 ; b
>>> c = b + 1.2 ; c
>>> a = 8 ; b
# la modification de la valeur de a n'entraine aucune modification
# de la valeur de b (contrairement aux cellules liées d'un tableur)

On peut affecter simultanément plusieurs valeurs à plusieurs variables.

>>> d, e = 6, 7.8
>>> print(d) ; print(e)
# et cette syntaxe permet même d'intervertir le contenu de deux variables
>>> d, e = e, d
>>> print(d) ; print(e)

D'autres types de variables :

>>> f = "bienvenue" ; f
>>> g = a < b ; g
>>> h = (a, b) ; h
>>> i = [a, b] ; i

La fonction type() permet de connaitre le type d’une valeur. Le type d’une variable est celui de la valeur qu'elle référence : il peut éventuellement changer au cours d’un programme.

Rechercher à l'aide de la console le type de chacune des variables préalablement définies : a, b, c,d, e, f, g, h et i.

Types de données en Python

Les principaux types de données en Python sont les nombres entiers, les nombres flottants, les booléens, les chaines de caractères, les listes et les p-uplets.

Entiers et flottants

Les entiers (type int) et flottants (type float) sont les deux types principaux pour les valeurs numériques réelles. Le type int n’est limité en taille que par la mémoire de la machine.
La fonction int() renvoie la troncature à l’entier d'un réel.

Les flottants sont notés avec un point décimal ou en notation exponentielle. Leur précision est limitée. (Ils sont représentés sur 64 bits selon la norme IEEE 754 double précision.)

Les notations contenant un point décimal, un quotient ou une écriture scientifique sont interprétées comme des flottants. Ainsi chacune des écritures suivantes : 2.0, 0.1, 2/3, 2.54e3, 2e-3 correspond à un flottant.

La fonction float() permet de convertir un entier en flottant.

Observer le résultat de chaque instruction dans la console :

>>> 2**10000
>>> 10**20 + 10**40
>>> 1e20 + 1e40
>>> 8 / 2

Les booléens

Les booléens (type bool) sont des données qui ne peuvent prendre que deux valeurs : False ou True.
L’évaluation d’une comparaison < ; > ; <= ; >= ;== (test d’égalité), != (test de différence) a pour valeur un booléen.

Anticiper le résultat de chaque instruction dans la console et vérifier le résultat affiché. Quelques surprises sont possibles...

>>> 2 + 3 == 5
>>> 0.2 + 0.3 == 0.5
>>> 0.2 + 0.1 == 0.3
>>> x = 14 ; x % 2 == 0
>>> x >= 20
>>> 12 < x <= 20

Les chaines de caractères

Les chaines de caractères (type str) sont composées de caractères Unicode. Elles sont délimitées par des " ou des (voire des triples guillemets ''').

  • Chaque caractère de la chaine a un indice positif : le premier caractère porte l’indice 0, et les indices augmentent de gauche à droite.
  • Chaque caractère de la chaine a un indice négatif. Le dernier caractère porte l'indice -1, et les indices diminuent de droite à gauche.
  • On peut accéder à la valeur d'un caractère à partir de son indice : nom_chaine[indice].
  • La fonction len() donne la longueur d'une chaine, c'est à dire le nombre de ses caractères.
  • On ne peut pas modifier directement un caractère d’une chaine, mais certaines opérations sont possibles comme la concaténation (+), la duplication (*), etc.
  • On peut connaitre le code correspondant à un caractère avec la fonction ord et, réciproquement, connaitre le caractère correspondant à un entier avec la fonction chr.
  • On peut convertir un entier n en chaine de caractères avec la fonction str(n), et convertir une chaine de caractères en entier avec la fonction int().

Anticiper le résultat de chaque instruction dans la console et vérifier le résultat affiché.

>>> mot = "bonjour"
>>> mot[0]
>>> mot[1]
>>> mot[-1]
>>> len(mot)
>>> mot[0] = 'B'
>>> mot = "Bonjour"
>>> mot1 = "pom"; mot2 = "pon"
>>> mot3 = mot1 + mot2; mot3
>>> mot4 = mot1 * 4; mot4
>>> ord('Z')
>>> chr(65)
>>> str(2) + str(3)
>>> '2' + '3'
>>> int('2') + int('3')

Les listes

Les listes (type list) sont des séquences d'éléments qui peuvent être de type quelconque, éventuellement de types différents. Elles sont délimitées par des crochets [ ] et les éléments sont séparés par des virgules.

  • Chaque élément de la liste a un indice positif : le premier élément porte l’indice 0, et les indices augmentent de gauche à droite.
  • Chaque élément de la liste a un indice négatif. Le dernier élément porte l'indice -1, et les indices diminuent de droite à gauche.
  • La fonction len() donne la longueur d'une liste, c'est à dire le nombre de ses éléments.
  • On peut accéder à la valeur d'un élément à partir de son indice : nom_liste[indice].
  • On peut modifier la valeur de chaque élément en le ré-affectant :
    nom_liste[indice] = nouvelle_valeur
  • On peut ajouter un nouvel élément en fin de liste à l’aide de la méthode append() :
    nom_liste.append(nouvel_element)
  • On peut concaténer (+) deux listes.
  • On peut trier les éléments d'une liste à l’aide de la fonction sorted() : liste_triee = sorted(liste_initiale).
  • Les fonctions min()et max() donnent les valeurs minimales et maximales d'une liste contenant des valeurs numériques comparables.

Anticiper le résultat de chaque instruction dans la console et vérifier le résultat affiché.

>>> liste_1 = [10, 21, 13, 24, 5]; liste_2 = [16, 27]
>>> liste_1[0]
>>> liste_1[0] = 4 ; liste_1
>>> len(liste_1)
>>> liste_3 = liste_1 + liste_2 ; liste_3
>>> liste_3.append(18) ; liste_3
>>> max(liste_3)
>>> min(liste_3)
>>> liste_4 = sorted(liste_3) ; liste_4

Les p-uplets

Les p-uplets (type tuple) sont des séquences non modifiables (ou non "mutables"). Ils sont délimités par des parenthèses ( ). Ils sont notamment utilisés implicitement lorsqu’une fonction renvoie plusieurs valeurs.

Anticiper le résultat de chaque instruction dans la console et vérifier le résultat affiché.

>>> triplet = (1,2,3); couple = (4,5)
>>> triplet[0]
>>> triplet[0] = 8
>>> len(triplet)
>>> somme = triplet + couple ; somme

L’éditeur

L’éditeur permet de saisir des programmes en Python (on parle aussi de scripts), que l’on peut sauvegarder dans des fichiers dont l’extension est .py. L’exécution du programme permet d'appeler dans la console les fonctions et variables définies dans le script.

Extrait du document d’accompagnement Algorithmique et programmation (Eduscol, 2017):

Les élèves écriront des fonctions qui pourront être enregistrées dans des fichiers, appelés scripts ou modules, qu’on peut développer, enrichir et réutiliser lors de séances successives. Les scripts peuvent être exécutés dans un mode console, afin de tester et mettre au point les algorithmes et les programmes. L’exécution d’un script comportant la définition d’une fonction \(f\) ne produit aucun affichage particulier dans la console.

Voici un premier exemple d'utilisation de l'éditeur en lien avec la console :

Ouvrir la console dans un nouvel onglet

Après exécution du script, on peut appeler dans l'éditeur les fonctions \(f\) et \(g\), en donnant une valeur au paramètre.

>>> f(5)
>>> f(5) + g(5) == f(6)

Les fonctions

Déclaration

Les fonctions permettent de décomposer un programme en plusieurs éléments plus simples, plus lisibles et que l'on peut combiner. Une fonction associe un bloc d'instructions à un nom.

L'utilisation d'une fonction nécessite deux étapes :

  • sa déclaration : on définit le nom de la fonction, ses paramètres et les instructions à exécuter ;

  • son appel : on exécute la fonction pour des valeurs explicites des paramètres.

La déclaration d'une fonction est introduite par le mot-clé def, suivi du nom de la fonction, de ses paramètres entre parenthèses, de deux points, puis d’un bloc d’instructions indentées.

def nom_de_la_fonction(parametre_1, parametre_2,...):
    bloc dinstructions
Le bloc d’instructions s’appelle le corps de la fonction. Il doit être obligatoirement indenté et la fin de ce bloc marque la fin de la déclaration de fonction.

Une fonction peut renvoyer zéro, une ou plusieurs valeurs à l’aide de l'instruction return qui met fin à l’exécution de la fonction.

Un exemple :

def moyenne(a, b):
    m = (a + b) / 2
    return(m)

Saisir ce script, puis l’exécuter. La fonction moyenne peut alors être appelée dans la console ou dans une autre partie du même script. La saisie dans la console de moyenne(34,67) renvoie la valeur 50.5.

On peut également écrire dans le script, en dehors de la fonction : print(moyenne(34, 67)). Cela provoquera, à l’exécution du script, l’affichage (dans la console) de la moyenne de 34 et 67. Ce fonctionnement est requis pour les interfaces ne disposant pas d'une console, comme Codeskulptor3 par exemple.

Paramètres

La fonction moyenne définie ci-dessus possède deux paramètres aet b. L'appel de moyenneavec un nombre de paramètres différent de deux provoque une erreur.

Une fonction n’a pas nécessairement de paramètres. On peut par exemple écrire :

from random import randint
# cette instruction permet d'utiliser la fonction randint qui n'est pas
# disponible par défaut
def de( ):
    return(randint(1,6))
L’appel de la fonction de() provoque le tirage aléatoire d’un entier entre 1 et 6.

On lance deux dés dés équilibrés à 6 faces et on calcule la somme des numéros situés sur les faces supérieures. Dans un script, écrire une fonction qui simule cette expérience et en renvoie le résultat.

Variable locale

Une variable déclarée dans une fonction ne sera visible que dans cette fonction, et les confusions sont faciles si une autre variable porte le même nom. On parle de variable locale.

Anticiper l’affichage produit dans la console par l’exécution du script suivant et vérifier.

score = 0
def bonus():
    score = 50
    return(score)

print("affichage 1 : " , score)
print("affichage 2 : " , bonus())
print("affichage 3 : " , score)

Structures de contrôle

Structure conditionnelle

En Python, une structure conditionnelle est introduite par le mot clé if dont la syntaxe est :

if expression :
    bloc dinstructions exécuté si expression vaut True
expression a pour valeur un booléen.

Pour exécuter un autre bloc d’instructions lorsque expression a pour valeur False, on utilise le mot clé else avec la syntaxe suivante :

if expression :
    bloc dinstructions exécuté si expression vaut True
else :
    bloc dinstructions exécuté si expression vaut False

Après exécution du script suivant, quelle sera la valeur de terme_suivant(14) et de terme_suivant(15) ? Vérifier.

def terme_suivant(n):
    if n % 2 == 0:
        return (n // 2)
    else:
        return (3 * n + 1)

Si l'on souhaite tester plusieurs expressions, on peut utiliser le mot-clé elif, autant de fois que nécessaire entre if et else. (elif signifie sinon si).

if expression_1 :
    bloc dinstructions exécuté si expression_1 vaut True
elif expression_2 :
    bloc dinstructions exécuté si expression_2 vaut True
else :
    bloc dinstructions exécuté si expression_2 et expression_1 valent False

Structures de répétition

Boucles non bornées

En Python, une boucle non bornée est introduite par le mot clé while dont la syntaxe est :

while expression :
    bloc dinstructions à répéter tant que expression a pour valeur True
Cette boucle permet de répéter un bloc d'instructions tant qu'une expression (booléenne) est vraie. On utilise généralement cette boucle lorsqu'on ne connait pas le nombre d'itérations au préalable.

Après exécution du script suivant, quelle est la valeur de rebondir(1) et rebondir(2) ? Quelle interprétation donner aux valeurs affichées ?

def rebondir(h):
    hauteur = h
    rebond = 0
    while hauteur > 0.1 :
        hauteur = hauteur * 0.9
        rebond = rebond + 1
    return (rebond, hauteur)

Les boucles while présentent un risque de boucle infinie. Pour que la boucle prenne fin, il faut s'assurer que l'expression qui conditionne l'exécution du corps de la boucle prendra la valeur False, éventuellement après de très nombreuses étapes. Il faut donc s’assurer que la valeur de cette expression est bien modifiée par les instructions du corps de la boucle (ou par un événement).

Exemple :

La boucle suivante ne se termine jamais : la variable valeur n'est jamais modifiée dans le corps de la boucle. Seule une action de l’utilisateur peut interrompre l'exécution du programme.

compteur = 0
valeur = 0
while valeur == 0:
    compteur = compteur + 1
    print(compteur)

À l'inverse, si l'expression qui conditionne l'exécution du corps de la boucle a pour valeur False dès le départ, le corps de la boucle n’est jamais exécuté.

Boucles bornées

En Python, la boucle bornée est introduite par le mot clé for dont la syntaxe est :

for element in sequence:
    bloc d'instructions

element est une variable à laquelle il faut donner un nom, et qui prend successivement les valeurs des éléments de la séquence.
Le bloc d'instructions à exécuter dans le corps de la boucle est à indenter.

En première approche, on peut utiliser l'instruction suivante pour répéter n fois un bloc d'instructions :

for i in range(n):
    bloc à répéter n fois, i prenant les valeurs 0, 1, ..., n  1

La fonction range peut prendre 1, 2 ou 3 arguments.

  • for i in range(fin) : i prend les valeurs de 0 à fin − 1
  • for i in range(debut, fin) : i prend les valeurs de debut à fin − 1
  • for i in range(debut, fin, pas) : i prend les valeurs debut, debut + pas, debut + 2pas ,... jusqu’à ce que fin − 1 soit atteint ou dépassé.

Exemple :

range(10) génère la liste 0, 1, 2, 3, 4, 5, 6, 7, 8, 9

range(4, 10) génère la liste 4, 5, 6, 7, 8, 9

range(1, 12, 3) génère la liste 1, 4, 7, 10

range(5, -1, -1) génère la liste 5, 4, 3, 2, 1, 0

L'objet renvoyé par range() se comporte presque comme une liste, mais n'en est pas une. Cet objet génère les éléments de la séquence au fur et à mesure de l'itération, sans réellement produire la liste en tant que telle.

Après exécution du script suivant, quelle est la valeur de cumul_carre(2) et de cumul_carre(100)?

def cumul_carre(n):
    somme = 0
    for i in range(n + 1):
        somme = somme + i ** 2
    return (somme)

La boucle for en Python permet de parcourir n’importe quelle séquence : chaine de caratères, liste, p-uplet, etc.

Par exemple : for c in "Bonjour" permet à la variable c de prendre successivement la valeur de chacun des caractères de la chaine "Bonjour".

Retour en haut de la page