Introduction à Python

Durée estimée : 2 heures.

Objectifs de la série

Vous familiariser avec le langage Python.

Exercice 1 : Lire l’introduction à Python

Lisez le tutorial de Python.

Si vous voulez travailler chez vous, téléchargez Python depuis le site officiel. Pour les séances d’exercices, vous allez avoir besoin de la version 3.x de Python (ou ultérieure). Attention: les exercices ne sont pas compatibles avec Python 2.x.

Linux

Sous linux, vous pouvez éditer vos fichiers sources avec votre éditeur préféré (vi, nano, ...). Cependant, nous vous recommandons d’utiliser gedit car il reconnaît la syntaxe Python.

Il existe plusieurs façons d’exécuter son code. La plus simple est la suivante:

python3 monfichier.py

Python dispose d’une interface interactive permettant de débugger et tester différentes commandes. Pour appeler l’interface, il faut lancer python3 dans un terminal. Pour quitter l’interface, un simple exit() (ou Ctrl-D) suffit.

Windows

Utilisez Linux... ou sinon PyScripter est un environnement open-source de développement Python. Une fois le fichier zip téléchargé, le décompresser dans le répertoire de votre choix, puis lancer l’exécutable.

Vous pouvez également utiliser un éditeur qui reconnaît la syntaxe Python comme Notepad++ et PSPad. Puis vous pouvez exécuter votre code sur la ligne de commande en utilisant l’installation standard de Python:

python3 monfichier.py

(Le chemin vers l’exécutable python3 doit être présent dans votre paramètre de système %PATH%).

Exercice 2 : Bases du langage

Quelques exercices tout simples.

Introduction rapide à la programmation objet en Python

Dans les séries à venir, nous allons devoir utiliser des types de structures de données abstraits (TDA). Python offre la possibilité de créer des classes et de manipuler des objets. (La syntaxe complète pour la gestion de classe se trouve au chapitre 9 du tutoriel de Python).

Afin de vous familiariser avec la syntaxe Python, voici un petit exemple:

class Personne:

    def __init__(self, nom, age):
        """ constructeur """
        self.nom = nom
        self.age = age

    def anniversaire(self):
        self.age += 1

class Etudiant(Personne): # héritage

    def __init__(self, nom, age, section):
        """ constructeur """
        Personne.__init__(self, nom, age) # héritage
        self.section = section

    def __str__(self):
        """ surcharge la fonction qui retourne une représentation en String de l'objet """
        out = "Etudiant %s a %d ans et est en section: %s\n" % (self.nom, self.age, self.section)
        return out

    def changeSection(self, nouvelleSection):
        self.section = nouvelleSection


# liste globale
etudiants = []

def afficheEtudiants():
print("Listes des étudiants:\n")
for etud in etudiants:
    print("\t", etud)


toto = Etudiant("Toto", 23, "SSC")
print(toto)
toto.anniversaire()
toto.changeSection("INF")
print(toto)

L’exemple ci-dessus affichera:

Etudiant Toto a 23 ans et est en section: SSC
Etudiant Toto a 24 ans et est en section: INF

Étudions plus en détail cet exemple.

  • Tout d’abord, nous commençons par définir une classe Personne. Ensuite, nous définissons un constructeur (__init__ (self,...)) qui met à jour les attributs publics nom et age, et une méthode anniversaire qui incrémente d’une unité l’âge d’une personne.
  • De plus, nous définissons une autre classe Etudiant qui est elle-même une sous-classe de Personne. Comme vous pouvez le constater, le constructeur de la classe Etudiant fait appel au constructeur de la classe Personne pour instantier les attributs nom et age (vu qu’ils sont hérités).
  • La méthode __str__(self) est une méthode de la classe Object et héritée (mais peut être surchargée). Dans la classe Etudiant, la méthode __str__(self) retourne une string de l’objet .

Avertissement

Contrairement à beaucoup de langages de programmation, Python ne vous laisse pas décider comment sont passés les paramètres (par références ou par valeurs). Python travaille en object-reference, qui est en fait une combinaison du passage en référence et par valeur. Plus concrètement, si le paramètre est un objet mutable (une liste, un dictionnaire, notre classe Personne), alors l’objet est passé en référence. Cependant, si l’objet n’est pas mutable (nombre, string, tuple), alors le paramètre est passé en valeur.

Avertissement

Vu l’ambiguïté causée par la passage en paramètre, certaines fonctions (comme append, extend, sort) retourneront None si on travaille sur des listes mutables (comme c’est le cas dans notre exemple). Ceci est normal, car il y a eu beaucoup de confusion dans le passé de savoir si ces fonctions retournaient un nouvel objet ou bien une référence sur l’ancien. La solution (simple) de ce problème est de ne pas directement retourner le résultat.

Pour comprendre ce problème, regardez l’exemple ci-dessous

toto = Etudiant("Toto",23,"INF")
titi = Etudiant("Titi",22,"SSC")
tata = Etudiant("Tata",25,"SSC")
etudiants=[toto,titi,tata]
print( etudiants.sort(key = lambda e : e.age)``)

Qui affichera

None

Tandis que

toto = Etudiant("Toto",23,"INF" )
titi = Etudiant("Titi",22,"SSC")
tata = Etudiant("Tata",25,"SSC")
etudiants=[toto,titi,tata]
etudiants.sort(key = lambda e : e.age)
afficheEtudiants()

affichera

Liste des étudiants:
    Etudiant Titi a 22 ans et est en section: SSC
    Etudiant Toto a 24 ans et est en section: INF
    Etudiant Tata a 25 ans et est en section: SSC