Notre premier outil développement est bien sur l’interpréteur python lui même utilisé pour lancer un fichier de code.

Installation

• Sur linux installer le paquet python3 (généralement déjà installé parce que linux utilise beaucoup python)
• Sur Windows installer depuis python.org ou depuis un outil comme chocolatey
• Sur MacOs déjà installé mais pour gérer un version plus à jours on peut le faire manuellement depuis python.org ou avec homebrew.

Python 2 vs Python 3

• Python 2 existe depuis 2000
• Python 3 existe depuis 2008
• Fin de vie de Python 2 en 2020
• … mais encore la version par défaut dans de nombreux système … (c.f. python --version)

Généralement il faut lancer python3 explicitement ! (et non python) pour utiliser python3

Différences principales

• print "toto" ne fonctionnera pas en Python 3 (utiliser print("toto")
• Nommage des paquets debian (python-* vs python3-*)
• Gestion de l’encodage
• range, xrange
• Disponibilité des librairies ?

Il existe des outils comme 2to3 pour ~automatiser la transition.

Executer un script explicitement avec python

$ python3 hello.py

ou implicitement (shebang)

#!/usr/bin/env python3

print("Hello, world!")

puis on rend le fichier executable et on l’execute

$ chmod +x hello.py
$ ./hello.py

Ex.0 Hello world

• Démarrer VS Code

• Écrire et lancer le programme suivant :

print("Hello World!")

• Créez un fichier hello.py directement dans la console (par exemple via nano hello.py) et mettez dedans :

#!/usr/bin/env python3
print("Hello, world!")

• Executez ensuite ce script à l’aide de python3 hello.py ou ./hello.py dans un terminal

En interactif

$ python3
>>> print("Hello, world!")

ipython3 : alternative à la console python ‘classique’

$ sudo apt install ipython3
$ ipython3
In [1]: print("Hello, world!")

Principaux avantages:

• Complétion des noms de variables et de modules avec TAB
• Coloré pour la lisibilité
• Plus explicite parfois
• des commandes magiques comme %cd, %run script.py,

Inconvénients:

• Moins standard
• à installer en plus de l’interpréteur python.

pour quitter : exit

Les éditeurs de code

VSCode est un éditeur de code récent et très à la mode, pour de bonnes raisons:

• Il est simple ou départ et fortement extensible: à l’installation seules les fonctionnalités de base sont disponibles
  • Éditeur de code avec coloration et raccourcis pratiques
  • Navigateur de fichier (pour manipuler une grande quantité de fichers et sous dossier sans sortir de l’éditeur)
  • Recherche et remplacement flexible avec des expressions régulières (très important pour trouver ce qu’on cherche et faire de refactoring)
  • Terminal intégrée (On a plein d’outils de développement à utiliser dans le terminal)
  • Une interface git assez simple très bien faite (git on s’y perd facilement, une bonne interface aide à s’y retrouver)

Indépendamment du logiciel choisi on trouve en général toutes ces fonctionnalités dans un éditeur de code.

Observons un peu tout ça avec une démo de VSCode et récapitulons l’importance des ces fonctions.

Installer des extensions pertinentes

Au sein de l’éditeur nous voulons coder en Python et également:

• Pouvoir détecter les erreurs de syntaxe.
• Pouvoir explorer le code python réparti dans plusieurs fichiers (sauter à la définition d’une fonction par exemple).
• Complétion automatique des noms de symboles (ça peut être pénible parfois).
• Pouvoir debugger le code python de façon agréable.
• Pouvoir refactorer (changer le nom de variables ou fonctions partout automatiquement).

Installez l’extension Python (et affichez la documentation si vous êtes curieux) en allant dans la section Extensions (Icone de gauche avec 4 carrés dont un détaché)

Nous allons également utiliser git sérieusement donc nous allons installer une super extension git appelée Gitgraph pour pouvoir mieux explorer l’historique d’un dépôt git.

Enfin vous pouvez installer d’autres extensions pour personnaliser l’éditeur comme l’extension VIM si vous aimez habituellement utiliser cet éditeur.

Opensource et extensibilité : ne pas s’enfermer dans un environnement de travail

• VSCode est développé par Microsoft et partiellement opensource (Le principal code est accessible mais pas tout)
• VSCodium est la version opensource communautaire de VSCode mais certaines fonctions puissantes et pratiques sont seulement dans VSCode (les environement distant Docker et SSH par exemple)
• Un fork récent et complètement opensource de VSCode qui peut fonctionner directement dans le navigateur (Cf. gitpod.io). Moins mature.

Ces trois logiciels sont très proches et vous pouvez coder vos extensions (compatibles avec les 3) pour étendre ces éditeur.

Il me semble important pour choisir un outil de se demander si on possède l’outil ou si l’outil nous possède (plus ou moins les deux en général). Pour pouvoir gérér la complexité du développement moderne on dépend de pas mal d’outils. Savoir choisir des outils ouverts et savoir utiliser également les outils en ligne commande (git, pylint, etc cf. suite du cours) est très important pour ne pas s’enfermer dans un environnement limitant et possessif.

1.1. Exemple

message = "Je connais la réponse à l'univers, la vie et le reste"
reponse = 6 * 7

print(message)
print(reponse)

1.2. Principe

• Les variables sont des abstractions de la mémoire
• Une étiquette collée apposée sur une partie de la mémoire : nom pointe vers un contenu
• Différent du concept mathématique

1.3. Déclaration, utilisation

• En python : déclaration implicite
• Ambiguité : en fonction du contexte, x désigne soit le contenant, soit le contenu…

x = 42     # déclare (implicitement) une variable et assigne une valeur
x = 3.14   # ré-assigne la variable avec une autre valeur
y = x + 2  # déclare une autre variable y, à partir du contenu de x
print(y)   # affichage du contenu de y

Nommage

• Caractères autorisés : caractères alphanumériques (a-zA-Z0-9) et _.
• Les noms sont sensibles à la casse : toto n’est pas la même chose que Toto!
• (Sans commencer par un chiffre)

Comparaison de différentes instructions

Faire un calcul sans l’afficher ni le stocker nul part:

6*7

Faire un calcul et l’afficher dans la console:

print(6*7)

Faire un calcul et stocker le résultat dans une variable r pour le réutiliser plus tard

r = 6*7

Opérations mathématiques

2 + 3   # Addition
2 - 3   # Soustraction
2 * 3   # Multiplication
2 / 3   # Division
2 % 3   # Modulo
2 ** 3  # Exponentiation

Calcul avec réassignation

x += 3   # Équivalent à x = x + 3
x -= 3   # Équivalent à x = x - 3
x *= 3   # Équivalent à x = x * 3
x /= 3   # Équivalent à x = x / 3
x %= 3   # Équivalent à x = x % 3
x **= 3  # Équivalent à x = x ** 3

Ex.1.1 Calculs dans l’interpréteur

• À l’aide de python, calculer le résultat des opérations suivantes :
  • 567×72
  • 33⁴
  • 98.2/6
  • ((7×9)⁴)/6
  • vrai et non (faux ou non vrai)

Types

42            # Entier / integer               / int
3.1415        # Réel                           / float
"Marius"        # Chaîne de caractère (string)   / str
True / False  # Booléen                        / bool
None          # ... "rien" / aucun (similar à `null` dans d'autres langages)

Connaître le type d’une variable : type(variable)

Conversion de type

int("3")      -> 3
str(3)        -> "3"
float(3)      -> 3.0
int(3.14)     -> 3
str(3.14)     -> "3.14"
float("3.14") -> 3.14
int(True)     -> 1
int("trois")  -> Erreur / Exception

Interactivité basique

Dans un terminal il est possible de demander une information à l’utilisateur avec `input(“message”)

reponse = input("Combien font 6 fois 7 ?")

N.B. : ce que renvoie input() est une chaîne de caractère !

Ex.1.2 Interactivité

• Demander l’année de naissance de l’utilisateur, puis calculer et afficher l’âge qu’il aura dans deux ans (approximativement, sans tenir compte du jour et mois de naissance…).

Syntaxe des chaînes

• Entre simple quote (') ou double quotes ("). Par exemple: "hello"
• print("hello") affiche le texte Hello
• print(hello) affiche le contenu d’une variable qui s’apellerait Hello

Longueur

m = "Hello world"
len(m)        # -> 11

Extraction

m[:5]    # -> 'Hello'
m[6:8]   # -> 'wo'
m[-3:]   # -> 'rld'

Multiplication

"a" * 6    # -> "aaaaaa"

Concatenation

"Cette phrase" + " est en deux morceaux."

name = "Marius"
age = 28
"Je m'appelle " + name + " et j'ai " + str(age) + " ans"

Construction à partir de données, avec %s

"Je m'appelle %s et j'ai %s ans" % ("Marius", 28)

Construction à partir de données, avec format

"Je m'appelle {name} et j'ai {age} ans".format(name=name, age=age)

Substitution

"Hello world".replace("Hello", "Goodbye")   # -> "Goodbye world"

Chaînes sur plusieurs lignes

• \n est une syntaxe spéciale faisant référence au caractère “nouvelle ligne”

"Hello\nworld"     # -> Hello <nouvelle ligne> world

Interactivité basique avec input

En terminal, il est possible de demander une information à l’utilisateur avec input("message")

reponse = input("Combien font 6 fois 7 ?")

N.B. : ce que renvoie input() est une chaîne de caractère !

Et bien d’autres choses !

c.f. documentation, e.g https://devdocs.io/python~3.7/library/stdtypes#str

Ex.2 Chaînes de caractères

2.1 Demander un mot à l’utilisateur. Afficher la longueur du mot avec une message tel que "Ce mot fait X caractères !"

2.2 Afficher le mot encadré avec des ####. Par exemple:

##########
# Python #
##########

Principe

Donner un nom à un ensemble d’instructions pour créer de la modularité et de la sémantique

def ma_fonction(arg1, arg2):
    instruction1
    instruction2
    ...
    return resultat

On peut ensuite utiliser la fonction avec les arguments souhaitées et récupérer le resultat :

mon_resultat = ma_fonction("pikachu", "bulbizarre")
autre_resultat = ma_fonction("salameche", "roucoups")

Calculs mathématiques

sqrt(2)        -> 1.41421 (environ)
cos(3.1415)    -> -1 (environ)

Générer ou aller chercher des données

nom_du_departement(67)        -> "Bas-rhin"
temperature_actuelle("Lyon")  -> Va chercher une info sur internet et renvoie 12.5

Convertir, formatter, filtrer, trier des données …

int("3.14")                     -> 3
normalize_url("toto.com/pwet/") -> https://toto.com/pwet
sorted(liste_de_prenoms)     -> renvoie la liste triée alphabétiquement

**Afficher / demander des données **

print("un message")
input("donne moi un chiffre entre 1 et 10 ?")

Exemples concrets

def aire_triangle(base, hauteur):
    return base * hauteur / 2

A1 = aire_triangle(3, 5)      # -> A1 vaut 15 !
A2 = aire_triangle(4, 2)      # -> A2 vaut 8 !


def aire_disque(rayon):
    rayon_carree = rayon ** 2
    return 3.1415 * rayon_carree

A3 = aire_disque(6)           # -> A3 vaut (environ) 113 !

def aire_triangle(base, hauteur):
    return base * hauteur / 2

A1 = aire_triangle(3, 5)      # -> A1 vaut 7.5 !
A2 = aire_triangle(4, 2)      # -> A2 vaut 8 !


def aire_disque(rayon):
    rayon_carree = rayon ** 2
    return 3.1415 * rayon_carree

A3 = aire_disque(6)           # -> A3 vaut (environ) 113


def volume_cylindre(rayon, hauteur):
    return hauteur * aire_disque(rayon)

V1 = volume_cylindre(6, 4)   # -> A4 vaut (environ) 452

Écrire une fonction

Éléments de syntaxe

def aire_disque(rayon):
    rayon_carree = rayon ** 2
    return 3.1415 * rayon_carree

• def, :
• des instructions indentées !!
• des arguments (ou pas!)
• return (ou pas)

Les arguments

def aire_disque(rayon):
    # [ ... ]

• Une fonction est un traitement générique. On ne connait pas à l’avance la valeur précise qu’aura un argument, et généralement on appelle la fonction pleins de fois avec des arguments différents…
• En définissant la fonction, on travaille donc avec un argument “abstrait” nommé rayon
• Le nom rayon en tant qu’argument de la fonction n’a de sens qu’a l’intérieur de cette fonction !
• En utilisant la fonction, on fourni la valeur pour rayon, par exemple: aire_disque(6).

Les variables locales

def aire_disque(rayon):
    rayon_carree = rayon ** 2
    # [ ... ]

• Les variables créées dans la fonction sont locales: elles n’ont de sens qu’a l’intérieur de la fonction
• Ceci dit, cela ne m’empêche pas d’avoir des variables aussi nommées rayon ou rayon_carree dans une autre fonction ou dans la portée globale (mais ce ne sont pas les mêmes entités)

Le return

def aire_disque(rayon):
    rayon_carree = rayon ** 2
    return 3.1415 * rayon_carree

• return permet de récupérer le résultat de la fonction
• C’est ce qui donne du sens à A = aire_disque(6) (il y a effectivement un résultat à mettre dans A)
• Si une fonction n’a pas de return, elle renvoie None
• return quitte immédiatement la fonction

Erreur classique:

Utiliser print au lieu de return

Ce programme n’affiche rien

def aire_disque(rayon):
    rayon_carree = rayon ** 2
    return 3.1415 * rayon_carree

A = aire_disque(6)      # A vaut bien quelque chose
                        # mais nous ne demandons pas de l'afficher ...

Solution naive : remplacer le return par un print

def aire_disque(rayon):
    rayon_carree = rayon ** 2
    print(3.1415 * rayon_carree)    # Affiche le résultat dans la console

A = aire_disque(6)   # Mais maintenant A vaut None
                     # car la fonction n'a pas utilisé `return`

“Bonne” solution

def aire_disque(rayon):
    rayon_carree = rayon ** 2
    return 3.1415 * rayon_carree

A = aire_disque(6)   # Stocker le résultat dans A
print(A)             # Demander d'afficher A dans la console

Ceci dit, il peut être tout à fait légitime de mettre des print dans une fonction, par exemple pour la débugger…!

Appel de fonction avec arguments explicites

def aire_triangle(base, hauteur):
    return base * hauteur / 2

A1 = aire_triangle(3, 5)
A2 = aire_triangle(4, hauteur=8)
A3 = aire_triangle(hauteur=6, base=2)
A4 = aire_triangle(hauteur=3, 2)    # < Pas possible !

N.B. : cette écriture est aussi plus explicite / lisible / sémantique:

aire_triangle(base=3, hauteur=5)

que juste

aire_triangle(3, 5)

On peut se retrouver dans des situations comme:

base = 3
hauteur = 5

A1 = aire_triangle(base=base, hauteur=hauteur)

Dans l’appel de la fonction :

• le premier base est le nom de l’argument de la fonction aire_triangle,
• le deuxième base corresponds au contenu de la variable nommée base.

Arguments optionnels

Les arguments peuvent être rendu optionnels si ils ont une valeur par défaut :

def distance(dx, dy=0, dz=0):
    [...]

Dans ce cas, tous ces appels sont valides :

distance(5)
distance(2, 4)
distance(5, 8, 2)
distance(9, dy=5)
distance(0, dz=4)
distance(1, dy=1, dz=9)
distance(2, dz=4, dy=7)

Exemple réaliste

subprocess.Popen(args,
                 bufsize=0,
                 executable=None,
                 stdin=None,
                 stdout=None,
                 stderr=None,
                 preexec_fn=None,
                 close_fds=False,
                 shell=False,
                 cwd=None,
                 env=None,
                 universal_newlines=False,
                 startupinfo=None,
                 creationflags=0)

c.f. https://docs.python.org/2/library/subprocess.html#subprocess.Popen

Ex.3 Fonctions

3.1 Écrire une fonction annee_naissance qui prends en argument un age et retourne l’année de naissance (+/- 1) sachant que nous sommes en 2019. Par exemple, annee_naissance(29) retounera l’entier 1990.

3.2

• Ecrire une fonction centrer prend en argument une chaîne de caractère, et retourne une nouvelle chaîne centrée sur 40 caractères. Par exemple print(centrer("Python")) affichera :

|                Python                |

• Ajouter un argument optionnel pour gérer la largeur au lieu du 40 “codé en dur”. Par exemple print(centrer("Python", 20)) affichera :

|      Python      |

• Créer une fonction encadrer qui utilise la fonction centrer pour produire un texte centré et encadré avec des ####. Par exemple, print(encadrer("Python", 20)) affichera :

####################
|      Python      |
####################

Pour pouvoir écrire des applications il faut des techniques permettant de contrôler le déroulement du programme dans différentes directions, en fonction des circonstances. Pour cela, nous devons disposer d’instructions capables de tester une certaine condition et modifier le comportement du programme en conséquence.

La principale instruction conditionnelle est, en python comme dans les autres langages impératifs, le if (Si condition alors …) assorti généralement du else (Sinon faire …) et en python de la contraction elif de else if (Sinon, Si condition alors …)e

Syntaxe générale

if condition:
    instruction1
    instruction2
elif (autre condition):
    instruction3
elif (encore autre condition):
    instruction4
else:
    instruction5
    instruction6

Attention à l’indentation !

Tout n’est pas nécessaire, par exemple on peut simplement mettre un if :

if condition:
    instruction1
    instruction2

Exemple

a = 0
if a > 0 :
    print("a est positif")
elif a < 0 :
    print("a est négatif")
else:
    print("a est nul")

Lien avec les booléens

Les conditions comme a > 0 sont en fait transformées en booléen lorsque la ligne est interprétée.

On aurait pu écrire :

a_est_positif = (a > 0)

if a_est_positif:
    [...]
else:
    [...]

Écrire des conditions

angle == pi      # Égalité
angle != pi      # Différence
angle > pi       # Supérieur
angle >= pi      # Supérieur ou égal
angle < pi       # Inférieur
angle <= pi      # Inférieur ou égal

Combiner des conditions

x = 2

print("x > 0:", x > 0) # vrai
print("x > 0 and x == 2:", x > 0 and x == 2) # vrai et vrai donne vrai
print("x > 0 and x == 1:", x > 0 and x == 2) # vrai et faux donne faux
print("x > 0 or x == 1:", x > 0 or x == 1) # vrai ou faux donne vrai
print("not x == 1:", not x == 1) # non faux donne vrai
print("x > 0 or not x == 1:", x > 0 or not x == 1) # vrai ou (non faux) donne vrai ou vrai donne vrai

Conditions “avancées”

Chercher des choses dans des chaînes de caractères

"Jack" in nom           # 'nom' contient 'Jack' ?
nom.startswith("Jack")  # 'nom' commence par 'Jack' ?
nom.endswith("ack")     # 'nom' fini par 'row' ?

Remarque: l’opérateur in est très utile et générale en Python: il sert à vérifier qu’un élément existe dans une collection. Par exemple si l’entier 2 est présent dans une liste d’entier ou comme ici si un mot est présent dans une chaine de caractère.

‘Inline’ ifs

On peut rassembler un if else sur une ligne comme suit:

parite = "pair" if n % 2 == 0 else "impair"

Tester si une variable a une valeur de façon “pythonique”.

En python pour tester si une variable contient une valeur vide ou pas de valeur (c-à-d valeur None) on aime bien, par convention “pythonique”, écrire simplement if variable: :

reste_division = a % 2

if reste_division:
    print("a est pair parce que le reste de sa division par 2 est nul")
else:
    print("a est impair")

Pareil pour tester si unt chaîne de caractère est vide ou nulle:

texte = input()

if texte:
    print("vous avez écrit: ", texte)
else:
    print("pas de texte")
    print("texte is None :", texte is None)
    print("texte == \"\" (chaine vide) :", texte == "")

Remarque: dans notre dernier cas il n’est pas forcément important de savoir si texte est None ou une chaîne vide mais plutôt de savoir si on a effectivement une valeur “significative” à afficher. C’est souvent le cas et c’est pour cela qu’on privilégie if variable pour simplifier la lecture du code.

Vraisemblance (truthiness) d’un valeur

L’usage de if variable: comme précédemment est basé sur la truthiness ou vraisemblance de la variable. On dit que a est vraisemblable si la conversion de a en booléen donne True : bool(3) donne True on dit que 3 est truthy, bool(None) donne False donc None est falsy. TODO Nous verrons dans la partie sur le Python Data Model que cela implique des choses pour nos classes de programmation orientée objet en python (en Résumé on veut que if monObjet: soit capable de tester si l’objet est initialisé et utilisable) Autrement dit en python on aime utiliser la vraisemblance implicite des variables pour tester si leur valeur est significative/initialisée ou non.

Ex.4 Conditions

4.1 Reprendre la fonction annee_naissance et afficher un message d’erreur et sortir immédiatement de la fonction si l’argument fourni n’est pas un nombre entre 0 et 130. Valider le comportement en appelant votre fonction avec comme argument -12, 158, None ou "toto".

• Inspecter l’execution du code pas à pas à l’aide du debugger VSCode.

4.2 Reprendre la fonction centrer de l’exercice 3.1 et gérer le cas où la largueur demandée est -1 : dans ce cas, ne pas centrer. Par exemple, print(encadrer("Python", -1)) affichera :

##########
# Python #
##########

Répéter des opération est le coeur de la puissance de calcul des ordinateur. On peut pour cela utiliser des boucles ou des appels récusifs de fonctions. Les deux boucles python sont while et for.

La boucle while

while <condition>: veut dire “tant que la condition est vraie répéter …”. C’est une boucle simple qui teste à chaque tour (avec une sorte de if) si on doit continuer de boucler.

Exemple:

a = 0
while (a < 10) # On répète les deux instructions de la boucle tant que a est inférieur à 7
    a = a + 1 # A chaque tour on ajoute 1 à la valeur de a
    print(a)

La boucle for et les listes

La boucle for en Python est plus puissante et beaucoup plus utilisée que la boucle while car elle “s’adapte aux données” et aux objets du programme grâce à la notion d’itérateur que nous détaillerons plus loin. (De ce point de vue, la boucle for python est très différente de celle du C/C++ par exemple)

On peut traduire la boucle Python for element in collection: en français par “Pour chaque élément de ma collection répéter …”. Nous avons donc besoin d’une “collection” (en fait un iterateur) pour l’utiliser. Classiquement on peut utiliser une liste python pour cela:

ma_liste = [7, 2, -5, 4]

for entier in ma_liste:
    print(entier)

Pour générer rapidement une liste d’entiers et ainsi faire un nombre défini de tours de boucle on utilise classiquement la fonction range()

print(range(10))

for entier in range(10):
    print(entier) # Afficher les 10 nombres de 0 à 9

for entier in range(1, 11):
    print(entier) # Afficher les 10 nombres de 1 à 10

for entier in range(2, 11, 2):
    print(entier) # Afficher les 5 nombres pairs de 2 à 10 (le dernier paramètre indique d'avancer de 2 en 2)

continue et break

continue permet de passer immédiatement à l’itération suivante

break permet de sortir immédiatement de la boucle

for i in range(0,10):
    if i % 2 == 0:
        continue

    print("En ce moment, i vaut " + str(i))

-> Affiche le message seulement pour les nombres impairs

for i in range(0,10):
    if i == 7:
        break

    print("En ce moment, i vaut " + str(i))

-> Affiche le message pour 0 à 6

Ex.5 Boucles

5.1.1 : Écrire une fonction qui, pour un nombre donné, renvoie la table de multiplication. Dans un premier temps, on pourra se contenter d’afficher les résultats. Par exemple print(table_du_7()) affichera:

7
14
21
...
70

puis ensuite on peut améliorer la présentation pour obtenir le résultat :

Table du 7
----------
 1 x 7 = 7
 2 x 7 = 14
 [..]
 10 x 7 = 70

5.1.2 : Cette fois, passer le nombre en argument. La fonction devient par exemple table_multiplication(7)

5.1.3 : En appelant cette fonction plusieurs fois, afficher les tables de multiplication pour tous les nombres entre 1 et 10.

5.1.4 : Protéger l’accès à toute cette connaissance précieuse en demandant, au début du programme, un “mot de passe” jusqu’à ce que le bon mot de passe soit donné.

5.2 : (Optionnel) Écrire une fonction qui permet de déterminer si un nombre est premier. Par exemple is_prime(3) renverra True, et is_prime(10) renverra False.

(Optionnel) 5.3.1 : Jeu des allumettes

Le jeu des allumettes est un jeu pour deux joueurs, où n allumettes sont disposées, et chaque joueur peut prendre à tour de rôle 1, 2 ou 3 allumettes. Le perdant est celui qui se retrouve obligé de prendre la dernière allumette.

• Écrire une fonction afficher_allumettes capable d’afficher un nombre donné d’allumettes (donné en argument), par exemple avec le caractère |
• Écrire une fonction choisir_nombre qui demande à l’utilisateur combien d’allumette il veut prendre. Cette fonction vérifiera que le choix est valide (en entier qui est soit 1, 2 ou 3).
• Commencer la construction d’une fonction partie_allumettes qui pour le moment, se contente de :
  • Initialiser le nombre d’allumette sur la table
  • Afficher des allumettes avec afficher_allumettes
  • Demander à l’utilisateur combien il veut prendre d’allumettes avec choisir_nombre
  • Propager ce choix sur le nombre d’allumette actuellement sur la table
  • Afficher le nouvel état avec afficher_allumettes

5.3.2 : (Optionnel) Modifier partie_allumettes pour gérer deux joueurs (1 et 2) et les faire jouer à tour de rôle jusqu’à ce qu’une condition de victoire soit détectée (il reste moins d’une allumette…).

5.3.3 : (Optionnel) Intelligence artificielle

Reprendre le jeu précédent et le modifier pour introduire une “intelligence” artificielle qui soit capable de jouer en tant que 2ème joueur. (Par exemple, une stratégie très simple consiste à prendre une allumette quoiqu’il arrive)

5.3.4 : (Optionnel) Installer pylint3 avec:

pip3 install pylint3

Analyser son code avec pylint3

Écrire un programme … pour qui ? pour quoi ?

Le fait qu’un programme marche n’est pas suffisant voire parfois “secondaire” !

• … Mieux vaut un programme cassé mais lisible (donc débuggable)
• … qu’un programme qui marche mais incompréhensible (donc fragile et/ou qu’on ne saura pas faire évoluer)
• … et donc qui va surtout faire perdre du temps aux futurs développeurs

Autrement dit : la lisibilité pour vous et vos collègues a énormément d’importance pour la maintenabilité et l’évolution d’un projet

Posture de développeur et bonnes pratiques

• Lorsqu’on écrit du code, la partie “tester” et “debugger” fait partie du job.

On écrit pas un programme qui marche au premier essai

• Il faut tester et débugger au fur et à mesure, pas tout d’un seul coup !

Le debugging interactif : pdb, ipdb, VSCode

• PDB = Python DeBugger

• Permet (entre autre) de définir des “break points” pour rentrer en interactif

  • import ipdb; ipdb.set_trace()
  • en 3.7 : breakpoint() Mais fait appel à pdb et non ipdb ?

• Une fois en interactif, on peut inspecter les variables, tester des choses, …

• On dispose aussi de commandes spéciales pour executer le code pas-à-pas

• Significativement plus efficace que de rajouter des print() un peu partout !

Commandes pdb et ipdb

• l(ist) : affiche les lignes de code autour de code (ou continue le listing precedent)

• c(ontinue) : continuer l’execution normalement (jusqu’au prochain breakpoint)

• s(tep into) : investiguer plus en détail la ligne en cours, possiblement en descendant dans les appels de fonction

• n(ext) : passer directement à la ligne suivante

• w(here) : print the stack trace, c.a.d. les différents sous-appels de fonction dans lesquels on se trouve

• u(p) : remonte d’un cran dans les appels de la stacktrace

• d(own) : redescend d’un cran dans les appels de la stacktrace

• b(reak) : fixe un point d’arrêt (breakpoint) à la ligne donnée.

• tbreak : fixe un point d’arrêt temporaire qui sera retiré au premier passage.

• pp <variable> : pretty-print d’une variable (par ex. une liste, un dict, ..)

Debug VSCode

• Dans VSCode on peut fixer des breakpoints (points rouges) directement dans le code en cliquant sur la colonne de gauche de l’éditeur.
• Il faut ensuite aller dans l’onglet debug et sélectionner une configuration de debug ou en créer une plus précise (https://code.visualstudio.com/docs/python/python-tutorial)
• Ensuite on lance le programme en mode debug et au moment de l’arrêt il est possible d’explorer les valeurs de toutes les variables du programme (Démo)

Bonnes pratiques pour la lisibilité, maintenabilité

• Keep It Simple

• Sémantique : utiliser des noms de variables et de fonctions qui ont du sens

• Architecture : découper son programme en fonction qui chacune résolvent un sous-problème précis

• Robustesse : garder ses fonctions autant que possibles indépendantes, limiter les effets de bords

  • lorsque j’arose mes plantes, ça ne change pas la température du four

• Lorsque mon programme évolue, je prends le temps de le refactoriser si nécessaire

  • si je répète plusieurs fois les mémes opérations, il peut être intéressant d’introduire une nouvelle fonction
  • si le contenu d’une variable ou d’une fonction change, peut-être qu’il faut modifier son nom
  • si je fais pleins de petites opérations bizarre, peut-être qu’il faut créer une fonction

Quelques programmes réels utilisant Python

Dropbox

Atom

Eve online

Matplotlib

Blender

OpenERP / Odoo

Tartiflette

Ex.6 Performances et debugging : plusieurs implémentations de la suite de fibonacci

La célèbre suite de Fibonacci, liée au nombre d’or, est une suite d’entiers dans laquelle chaque terme est la somme des deux termes qui le précèdent. Mais elle est également un exercice classique d’algorithmique.

• Écrire une fonction fibonacci_rec_naive(n) qui calcule de façon récursive la suite de fibonacci.

• Créez une autre fonction fibonacci_iter(n) qui calcule de façon iterative la suite de fibonacci.

• Calculez le 40e terme de la suite avec chacune des implémentation précédente.

• Debuggez les deux implémentations. Que se passe-t-il ?

• A l’aide de la librairie timeit et de sa fonction timer (from timeit import default_timer as timer) qui renvoie le temps processeur courant, mesurez le temps d’exécution des deux fonctions.

• Écrire une fonction fibonacci_rec_liste(n) qui calcule récursivement la suite de fibonacci en utilisant une liste comme mémoire pour ne pas recalculer les terme déjà calculés.

• Bonus 1: Utilisons un décorateur de “caching” de fonction (from functools import lru_cache as cache) sur fibonacci_rec_naive(n) pour l’optimiser sans changer le code.

• Bonus 2: Écrivons une implémentation pythonique de fibonacci utilisant un générateur

Les structures de données permettent de stocker des séries d’information et d’y accéder (plus ou moins) facilement et rapidement.

Les listes

Une collection d’éléments ordonnés référencé par un indice

animaux_favoris = [ "girafe", "chenille", "lynx" ]
fibonnaci = [ 1, 1, 2, 3, 5, 8 ]
stuff = [ 3.14, 42, "bidule", ["a", "b", "c"] ]

Accès à element particulier ou a une “tranche”

animaux_favoris[1]      ->  "chenille"
animaux_favoris[-2:]    ->  ["chenille", "lynx"]

Longueur

len(animaux_favoris)    -> 3

Tester qu’un élément est (ou n’est pas) dans une liste

"lynx" in animaux_favoris   # -> True
"Mewtwo" not in animaux_favoris   # -> True

animaux_favoris = [ "girafe", "chenille", "lynx" ]

Iteration

for animal in animaux_favoris:
    print(animal + " est un de mes animaux préférés !")

Iteration avec index

print("Voici la liste de mes animaux préférés:")
for i, animal in enumerate(animaux_favoris):
    print(str(i+1) + " : " + animal)

animaux_favoris = [ "girafe", "chenille", "lynx" ]

Modification d’un élément

animaux_favoris[1] = "papillon"

Ajout à la suite, contatenation

animaux_favoris.append("coyote")

Insertion, concatenation

animaux_favoris.insert(1, "sanglier")
animaux_favoris += ["lion", "moineau"]

Exemple de manip classique : filtrer une liste pour en construire une nouvelle

animaux_favoris = [ "girafe", "chenille", "lynx" ]

# Création d'une liste vide
animaux_starting_with_c = []

# J'itère sur la liste de pokémons favoris
for animal in animaux_favoris:

   # Si le nom de l'animal actuel commence par c
   if animal.startswith("c"):

      # Je l'ajoute à la liste
      animaux_starting_with_B.append(animal)

À la fin, animaux_starting_with_c contient:

["girafe"]

Transformation de string en liste

"Hello World".split()    -> ["Hello", "World"]

Transformation de liste en string

' | '.join(["a", "b", "c"])      -> "a | b | c"

Les dictionnaires

Une collection non-ordonnée (apriori) de clefs a qui sont associées des valeurs

phone_numbers = { "Alice":   "06 93 28 14 03",
                  "Bob":     "06 84 19 37 47",
                  "Charlie": "04 92 84 92 03"  }

Accès à une valeur

phone_numbers["Charlie"]        -> "04 92 84 92 03"
phone_numbers["Marius"]           -> KeyError !
phone_numbers.get("Marius", None) -> None

Modification d’une entrée, ajout d’une nouvelle entrée

phone_numbers["Charlie"] = "06 25 65 92 83"
phone_numbers["Deborah"] = "07 02 93 84 21"

Tester qu’une clef est dans le dictionnaire

"Marius" in phone_numbers    # -> False
"Bob" not in phone_numbers # -> False

phone_numbers = { "Alice":   "06 93 28 14 03",
                  "Bob":     "06 84 19 37 47",
                  "Charlie": "04 92 84 92 03"  }

Iteration sur les clefs

for prenom in phone_numbers:     # Ou plus explicitement: phone_numbers.keys()
    print("Je connais le numéro de "+prenom)

Iteration sur les valeurs

for phone_number in phone_numbers.values():
    print("Quelqu'un a comme numéro " + phone_number)

Iterations sur les clefs et valeurs

for prenom, phone_number in phone_numbers.items():
    print("Le numéro de " + prenom + " est " + phone_number)

Construction plus complexes

Liste de liste, liste de dict, dict de liste, dict de liste, …

contacts = { "Alice":  { "phone": "06 93 28 14 03",
                         "email": "alice@megacorp.eu" },

             "Bob":    { "phone": "06 84 19 37 47",
                         "email": "bob.peterson@havard.edu.uk" },

             "Charlie": { "phone": "04 92 84 92 03" } }

contacts = { "Alice":  { "phone": "06 93 28 14 03",
                         "email": "alice@megacorp.eu" },

             "Bob":    { "phone": "06 84 19 37 47",
                         "email": "bob.peterson@harvard.edu.uk" },

             "Charlie": { "phone": "04 92 84 92 03" } }

Recuperer le numero de Bob

contacts["Bob"]["phone"]   # -> "06 84 19 37 47"

Ajouter l’email de Charlie

contacts["Charlie"]["email"] = "charlie@orange.fr"

Ajouter Deborah avec juste une adresse mail

contacts["Deborah"] = {"email": "deb@hotmail.fr"}

Les sets

Les sets sont des collections d’éléments unique et non-ordonnée

chat = set(["c", "h", "a", "t"])        # -> {'h', 'c', 'a', 't'}
chien = set(["c", "h", "i", "e", "n")   # -> {'c', 'e', 'i', 'n', 'h'}
chat - chien                            # -> {'a', 't'}
chien - chat                            # -> {'i', 'n', 'e'}
chat & chien                            # -> {'h', 'c'}
chat | chien                            # -> {'c', 't', 'e', 'a', 'i', 'n', 'h'}
chat.add("z")                           # ajoute `z` à `chat`

Les tuples

Les tuples permettent de stocker des données de manière similaire à une liste, mais de manière non-mutable. Generalement itérer sur un tuple n’a pas vraiment de sens…

Les tuples permettent de grouper des informations ensembles. Typiquement : des coordonnées de point.

xyz = (2,3,5)
xyz[0]        # -> 2
xyz[1]        # -> 3
xyz[0] = 5    # -> Erreur!

Autre exemple dictionnaire.items() renvoie une liste de tuple (clef, valeur) :

[ (clef1, valeur1), (clef2, valeur2), ... ]

List/dict comprehensions

Les “list/dict comprehensions” sont des syntaxes particulière permettant de rapidement construire des listes (ou dictionnaires) à partir d’autres structures.

Syntaxe (list comprehension)

[ new_e for e in liste if condition(e) ]

Exemple (list comprehension)

Carré des entiers impairs d’une liste

[ e**2 for e in liste if e % 2 == 1 ]

List/dict comprehensions

Les “list/dict comprehensions” sont des syntaxes particulière permettant de rapidement construire des listes (ou dictionnaires) à partir d’autres structures.

Syntaxe (dict comprehension)

{ new_k:new_v for k, v in d.items() if condition(k, v) }

Exemple (dict comprehension)

{ nom: age-20 for nom, age in ages.items() if age >= 20 }

Générateurs

(Pas vraiment une structure de données, mais c’est lié aux boucles …)

• Une fonction qui renvoie des résultats “au fur et à mesure” qu’ils sont demandés …
• Se comporte comme un itérateur
• Peut ne jamais s’arrêter …!
• Typiquement, évite de créer des listes intermédiaires

exemple SANS generateur

mes_animaux = { "girafe": 300,    "coyote": 50,
                 "chenille": 2,       "cobra": 45
                 # [...]
               }

def au_moins_un_metre(animaux):

    output = []
    for animal, taille in animaux.items():
        if taille >= 100:
            output.append(animal)

    return output

for animal in au_moins_un_metre(mes_animaux):
   ...

exemple AVEC generateur

mes_animaux = { "girafe": 300,    "coyote": 50,
                 "chenille": 2,       "cobra": 45
                 # [...]
               }

def au_moins_un_metre(animaux):

    for animal, taille in animaux.items():
        if taille >= 100:
            yield animal

for animal in au_moins_un_metre(mes_animaux):
   ...

Il n’est pas nécessaire de créer la liste intermédiaire output

Un autre exemple

def factorielle():

   n = 1
   acc = 1

   while True:
       acc *= n
       n += 1

       yield acc

Ex.7 Structures de données

7.1 : Écrire une fonction qui retourne le plus grand élément d’une liste (ou d’un set) de nombres, et une autre fonction qui retourne le plus petit. Par exemple, plus_grand([5, 9, 12, 6, -1, 4]) retournera 12.

assert plus_grand([5, 9, 12, 6, -1, 4]) == 12
assert plus_grand([-6, -19, -2]) == -2
assert plus_petit([5, 9, 12, 6, -1, 4]) == -1
assert plus_petit([-6, -19, -2]) == -19

7.2 : Écrire une fonction qui retourne le mot le plus long parmis une liste de mot donnée en argument.

assert plus_long(["Paris", "Amsterdam", "Londres"]) == "Amsterdam"
assert plus_long(["Choucroute", "Pizza", "Tarte flambée"]) == "Tarte flambée"

7.3 : Écrire une fonction qui calcule la somme d’une liste de nombres.

assert somme([3, 4, 5]) == 12
assert somme([0, 7, -3]) == 4

7.4 : Écrire une fonction qui prends en argument un chemin de fichier comme “/usr/bin/toto.py” et extrait le nom du fichier, c’est à dire “toto”. On pourra utiliser la méthode chaine.split(caractere) des chaînes de caractère.

7.5.1 : Récuperer le dictionnaire d’exemple auprès du formateur (example_dict.py) et boucler sur ce dictionnaire pour afficher quelque chose comme:

Sebastian est né.e en 1979
Barclay est né.e en 2000
Vivien est né.e en 1955
...

example_dict=[{'name': 'Sebastian', 'email': 'Donec.felis.orci@consectetueripsumnunc.edu', 'country': '1979'}, {'name': 'Barclay', 'email': 'aliquet.metus.urna@neceleifend.co.uk', 'country': '2000'}, {'name': 'Vivien', 'email': 'pharetra@a.com', 'country': '1955'}, {'name': 'Britanney', 'email': 'eu.tellus.Phasellus@arcuvelquam.ca', 'country': '1961'}, {'name': 'Reese', 'email': 'tortor.dictum.eu@egestasSed.ca', 'country': '1951'}, {'name': 'Keegan', 'email': 'libero.nec@cursuset.co.uk', 'country': '1998'}, {'name': 'Ezekiel', 'email': 'tempus.mauris.erat@aclibero.org', 'country': '1951'}, {'name': 'Odessa', 'email': 'massa.Quisque.porttitor@felis.net', 'country': '1925'}, {'name': 'Elijah', 'email': 'luctus.vulputate.nisi@nunc.com', 'country': '1963'}, {'name': 'Hilel', 'email': 'lectus.pede.et@aliquetsem.ca', 'country': '1982'}, {'name': 'Callie', 'email': 'et.euismod.et@aliquetmagnaa.net', 'country': '1984'}, {'name': 'India', 'email': 'Duis.sit.amet@Phaselluslibero.com', 'country': '1938'}, {'name': 'Lane', 'email': 'amet@turpis.ca', 'country': '1922'}, {'name': 'Alexis', 'email': 'sagittis.placerat@nibhdolor.net', 'country': '1927'}, {'name': 'Micah', 'email': 'lorem.eget.mollis@SeddictumProin.com', 'country': '1914'}, {'name': 'Rigel', 'email': 'sollicitudin@eratinconsectetuer.org', 'country': '1941'}, {'name': 'Avram', 'email': 'tincidunt.vehicula@vulputate.org', 'country': '1919'}, {'name': 'Dieter', 'email': 'ornare.lectus.justo@Integeridmagna.org', 'country': '1937'}, {'name': 'Sarah', 'email': 'cubilia.Curae.Phasellus@non.net', 'country': '1946'}, {'name': 'Graham', 'email': 'elit.Curabitur.sed@maurisIntegersem.edu', 'country': '1931'}, {'name': 'Daquan', 'email': 'fermentum.convallis.ligula@porttitorinterdum.co.uk', 'country': '1934'}, {'name': 'Nell', 'email': 'purus@lectusconvallisest.org', 'country': '1997'}, {'name': 'Ocean', 'email': 'ut@Nuncquisarcu.net', 'country': '2006'}, {'name': 'Cruz', 'email': 'Aenean.euismod.mauris@idmollisnec.edu', 'country': '1950'}, {'name': 'Hyacinth', 'email': 'amet@Nunc.edu', 'country': '1929'}]

7.5.2 : Transformer le programme précédent pour n’afficher que les personnes ayant une adresse mail finissant par .edu.

7.6 : Ecrire une fonction compte_lettres qui prends en argument une (grande) chaîne de caractère et retourne un dictionnaire avec un compte des occurences des lettres. Par exemple compte_lettres("hello") retournera {"h":1, "l": 2, "o": 1, "e":1 }. Utiliser cette fonction sur Lorem Ipsum (“Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt […]")

7.7 : Écrire une fonction qui retourne seulement les entiers pairs d’une liste

7.8 : Écrire une fonction qui permet de trier une liste (ou un set) d’entiers

7.9 : En une seule ligne de code, générer la matrice suivante :

[ [ 0, 1, 2, 3,  4  ],
  [ 0, 2, 4, 6,  8  ],
  [ 0, 3, 6, 9,  12 ],
  [ 0, 4, 8, 12, 16 ] ]

7.10 : Réécrire la fonction somme du 8.2, mais cette fois sans utiliser de variable intermédiaire (utiliser la récursivité)

7.11 : Ecrire un générateur carre() qui genere la suite 1, 4, 9, 16, … Utiliser ce générateur pour afficher les carrés jusqu’à ce qu’une valeur dépasse 200.

7.12 : Ecrire un générateur fibonnaci qui genere la suite de fibonnaci 0, 1, 1, 2, 3, 5, 8, … Utiliser ce générateur pour afficher les valeurs jusqu’à ce qu’elles dépassent 500.

Programmation impérative / procédurale

• Comme une recette de cuisine qui manipule de l’information
• Une suite d’opération à effectuer
• Différents concepts pour construire ces opérations:
  • des variables
  • des fonctions
  • des conditions
  • des boucles
  • des structures de données (listes, dictionnaires)

Variables

x = "Toto"
x = 40
y = x + 2
print("y contient " + str(y))

Fonctions

def aire_triangle(base, hauteur):
    calcul = base * hauteur / 2
    return calcul

A1 = aire_triangle(3, 5)      # -> A1 vaut 15 !
A2 = aire_triangle(4, 2)      # -> A2 vaut 8 !

• Indentation
• Arguments (peuvent être optionnels si on spécifie une valeur par défaut)
• Variables locales
• return pour pouvoir récupérer un résultat depuis l’extérieur
• Appel de fonction

Conditions

def aire_triangle(base, hauteur):

    if base < 0 or hauteur < 0:
        print("Il faut donner des valeurs positives!")
        return -1

    calcul = base * hauteur / 2
    return calcul

• Indentation
• Opérateurs (==, !=, <=, >=, and, or, not, in, …)
• Mot clefs if, elif, else

Listes, dictionnaires et boucles

breakfast = ["Spam", "Eggs", "Bacon", "Spam"]
breakfast.append("Coffee")

print("Au petit dej' je mange: ")
for stuff in breakfast:
    print(stuff)

ingredients_gateau = {"farine": 200,
                      "beurre": 100,
                      "chocolat": 150}

for ingredient, qty in ingredients_gateau.items():
    print("J'ai besoin de " + str(qty) + "g de " + ingredient)

Algorithmes simples : max

def max(liste_entiers):
    if liste_entiers == []:
        print("Erreur, peut pas calculer le max d'une liste vide")
        return None

    m = liste_entiers[0]
    for entier in liste_entiers:
        if m < entier:
            m = entier

    return m

Algorithmes simples : filtrer une liste

def pairs(liste_entiers):

    resultat = []

    for entier in liste_entiers:
        if entier % 2 == 0:
            resultat.append(entier)

    return resultat

En Python, lorsqu’une erreur se produit ou qu’un cas particulier empêche (a priori) la suite du déroulement normal d’un programme ou d’une fonction, une exception est déclenchée

Attention : différent des erreurs de syntaxe

Exemple d’exceptions

• Utiliser une variable qui n’existe pas

• Utiliser int() sur quelque chose qui ne peut pas être converti en entier

• Diviser un nombre par zero

• Diviser un nombre par une chaine de caractère

• Tenter d’accéder à un élément d’une liste qui n’existe pas

• Tenter d’ouvrir un fichier qui n’existe pas ou qu’on ne peut pas lire

• Tenter de télêcharger des données sans être connecté à internet

• etc…

• Une exception a un type (c’est un objet d’un classe d’exception -> cf. Partie 3):

  • Exception, ValueError, IndexError, TypeError, ZeroDivisionError, …

• Lorsqu’une exception interrompt le programme, l’interpréteur affiche la stacktrace (TraceBack) qui contient des informations pour comprendre quand et pourquoi l’exception s’est produite.

Traceback (most recent call last):
  File "coucou.py", line 3, in <module>
    print(coucou)
NameError: name 'coucou' is not defined

# python3 test_int.py

Tapez un entier entre 1 et 3: truc

Traceback (most recent call last):
  File "test_int.py", line 8, in <module>
    demander_nombre()
  File "test_int.py", line 4, in demander_nombre
    r = int(input("Tape un entier entre 1 et 3: "))
ValueError: invalid literal for int() with base 10: 'truc'

Souvent une exception est due à une entrée utilisateur incorrecte (comme ici) mais pas toujours.

raise

Il est possible de déclencher ses propres exceptions à l’aide de raise

def max(liste_entiers):
    if liste_entiers == []:
        raise Exception("max() ne peut pas fonctionner sur une liste vide!")

(Ici, le type utilisé est le type générique Exception)

Autre exemple:

def envoyer_mail(destinataire, sujet, contenu):
    if '@' not in destinataire:
        raise Exception('Une adresse mail doit comporter un @ !')

(Ici, le type utilisé est le type générique Exception)

try/except

De manière générale dans un programme, il peut y’avoir beaucoup de manipulation dont on sait qu’elles peuvent échouer pour un nombre de raisons trop grandes à lister …

Par exemple : écrire dans un fichier

• Est-ce que le programme a la permission d’écrire dans ce fichier ?
• Est-ce qu’aucun autre programme n’est en train d’écrire dans ce fichier ?
• Est-ce qu’il y a assez d’espace disque libre ?
• Si je commence à écrire, peut-être vais-je tomber sur un secteur disque deffectueux
• …

Autre exemple : aller chercher une information sur internet

• Est-ce que je suis connecté à Internet ?
• Est-ce que la connection est suffisament stable et rapide ?
• Est-ce que le programme a le droit d’effectuer d’envoyer des requêtes ?
• Est-ce qu’un firewall va bloquer ma requête ?
• Est-ce que le site que je veux contacter est disponible actuellement ?
• Est-ce que le certificat SSL du site est à jour ?
• Quid de si la connexion est perdue en plein milieu de l’échange ?
• …

En Python, il est courant d'« essayer » des opérations puis de gérer les exceptions si elles surviennent.

On utilise pour cela des try: ... except: ....

Exemple

reponse = input("Entrez un entier svp !")

try:
    n = int(reponse)
except:
    raise Exception("Ce n'est pas un entier !")

Utilisation différente

reponse = input("Entrez un entier svp !")

try:
    n = int(reponse)
except:
    n = -1

while True:
    reponse = input("Entrez un entier svp !")

    try:
        n = int(reponse)
        break
    except:
        # Faire en sorte de boucler pour reposer la question à l'utilisateur ...
        print("Ce n'est pas un entier !")
        continue

Autre exemple (inhabituel):

On peut utiliser les exception comme une sorte de if ou inversement

def can_be_converted_to_int(stuff):
    try:
        int(stuff)
    except:
        return False

    return True

can_be_converted_to_int("3")    # -> True
can_be_converted_to_int("abcd") # -> False

The “python way”

« Better to ask forgiveness than permissions »

Traduction “on essaye et puis on voit et on gère les dégats”. (ça se discute)

Assertions

Il est possible d’utiliser des assertions pour expliciter certaines hypothèses faites pendant l’écriture du code. Si elles ne sont pas remplies, une exception est déclenchée.

Un peu comme un "if not condition raise error".

def max(liste_entiers):
    assert liste_entiers != [], "max() ne peut pas fonctionner sur une liste vide!"

(assert toto est équivalent à if not toto: raise Exception())

def distance(x=0, y=0):
    assert isinstance(x, (int, float)), "Cette fonction ne prends que des int ou float en argument !"
    assert isinstance(y, (int, float)), "Cette fonction ne prends que des int ou float en argument !"

    return racine_carree(x*x + y*y)

def some_function(n):
    assert n, "Cette fonction n'accepte pas 0 ou None comme argument !"
    assert n % 2 == 0, "Cette fonction ne prends que des entiers pairs en argument !"

    [...]

Assertions et tests unitaires

En pratique, l’une des utilisations les plus courantes de assert est l’écriture de tests unitaires qui permettent de valider qu’une fonction marche dans tous les cas (et continue à marcher si on la modifie)

Dans votre application:

def trier(liste_entiers):
    # on définie le comportement de la fonction

Dans les tests (fichier à part):

assert trier([15, 8, 4, 42, 23, 16]) == [4, 8, 15, 16, 23, 42]
assert trier([0, 82, 4, -21, 2]) == [-21, 0, 2, 4, 82]
assert trier([-7, -3, 0]) == [-7, -3, 0]
assert trier([]) == []

Cf. Chapitre 19

Calcul du max d’un liste d’entier : plusieurs approches !

Attention : dans les exemples suivant je dois penser au cas où resultat peut valoir None

Je soupçonne fortemment que ma_liste puisse ne pas être une liste ou puisse être vide

Soit je teste explicitement avant pour être sur (moins pythonique) !

if not isinstance(ma_liste, list) or ma_liste == []:
    resultat = None
else:
    resultat = max(ma_liste)

Ça devrait marcher, mais j’ai un doute …

Soit j’essaye et je gère les cas d’erreur (plus pythonique)!

try:
    resultat = max(ma_liste)
except ValueError as e:
    print("Warning : peut-etre que ma_liste n'etait pas une liste non-vide ?")
    resultat = None

Soit j’assert le test pour laisser la fonction appelante le soin de gérer l’entrée correctement

Normalement ma_liste est une liste non-vide, sinon il y a un très gros problème avant dans le programme…

assert isinstance(ma_liste, list) and ma_liste != []

resultat = max(ma_liste)

Dans ce cas la fonction

Lire “brutalement”

mon_fichier = open("/etc/passwd", "r")
contenu_du_fichier = mon_fichier.readlines()
mon_fichier.close()

for ligne in contenu_du_fichier:
    print(ligne)

Attention à bien distinguer:

• le nom du fichier (passwd) et son chemin d’accès absolu (/etc/passwd)
• le vrai fichier qui existe sur le disque
• la variable / objet Python (dans l’exemple, nommée f) qui est une interface pour interagir avec ce fichier

Lire, avec une “gestion de contexte”

with open("/etc/passwd", "r") as mon_fichier:
    contenu_du_fichier = mon_fichier.readlines()

for ligne in contenu_du_fichier:
    print(ligne)

Explications

• open("fichier", "r") ouvre un fichier en lecture
• with ... as ... ouvre un contexte, à la fin duquel le fichier sera fermé automatiquement
• f.readlines() permet d’obtenir une liste de toutes les lignes du fichier

Lire

• f.readlines() renvoie une liste contenant les lignes une par une

• f.readline() renvoie une ligne du fichier à chaque appel.

• f.read() renvoie une (grande) chaĩne contenant toutes les lignes concaténées

• Attention, si je modifie la variable contenu_du_fichier … je ne modifie pas vraiment le fichier sur le disque ! Pour cela, il faut explicitement demander à écrire dans le fichier.

Ecrire

En remplacant tout !

with open("/home/alex/test", "w") as f:
    f.write("Plop")

À la suite (« append »)

with open("/home/alex/test", "a") as f:
    f.write("Plop")

Fichiers et exceptions

try:
    with open("/some/file", "r") as f:
        lines = f.readlines()
except:
    raise Exception("Impossible d'ouvrir le fichier en lecture !")

Un autre exemple

try:
    with open("/etc/shadow", "r") as f:
        lines = f.readlines()
except PermissionError:
    raise Exception("Pas le droit d'ouvrir le fichier !")
except FileNotFoundError:
    raise Exception("Ce fichier n'existe pas !")

Note “technique” sur la lecture des fichiers

• Il y a un “curseur de lecture”. On peut lire petit morceaux par petit morceaux … une fois arrivé au bout, il n’y a plus rien à lire, il faut replacer le curseur si on veut de nouveau lire.

f = open("/etc/passwd")
print(f.read())  # ---> Tout plein de choses
print(f.read())  # ---> Rien !
f.seek(0)        # On remet le curseur au début
print(f.read())  # ---> Tout plein de choses !

Ex.10 Fichiers

10.1 : Créer un fonction liste_users qui lit le fichier /etc/passwd et retourne la liste des utilisateurs ayant comme shell de login /bin/bash.

10.2 : Dans le code Python, écrire un modèle d’email comme:

modele = """
Bonjour {prenom} !
Voici en pièce jointe les billets pour votre voyage en train vers {destination}.
"""

Ecrire une fonction generer_email qui remplace dans modele les chaines {prenom}et {destination} par des arguments fourni à la fonction, et enregistre le résultat dans un fichier email_{prenom}.txt. Par exemple, generer_email("Alex", "Strasbourg") générera le texte et sauvegardera le résultat dans email_Alex.txt.

10.3 : Écrire une fonction qui permet d’afficher un fichier sans les commentaires et les lignes vides. Spécifier le caractère qui symbolise le début d’un commentaire en argument de la fonction. (Ou pourra utiliser la méthode strip() des chaînes de caractère pour identifier plus facilement les lignes vides)

L’une des puissances de python vient de l’écosystème de librairie disponibles.

Librairie / bibliothèque / module : un ensemble de fonctionnalité déjà pensés et éprouvées, prêtes à l’emploi.

Syntaxes d’import

import un_module          # -> Importer tout un module
un_module.une_fonction()  # -> Appeler la fonction une_function()
                          #    du module

Exemple

import math

math.sqrt(2)   # -> 1.4142135623730951

Importer juste des choses précises

from un_module import une_fonction, une_autre

une_fonction(...)

Exemple

from math import sqrt, sin, cos

sqrt(2)   # -> 1.4142135623730951

Exemple : json

Le JSON est un format de fichier qui permet de décrire des données numériques complexe et imbriquées pour le stocker ou le transférer. Il s’agit du format de données dominant aujourd’hui sur le web. Il est utilisé dans tous les langages et Python intègre à l’installation une librairie pour le manipuler.

A noter également qu’il est quasiment isomorphe à un dictionnaire Python.

{
    "mailman": {
        "branch": "master",
        "level": 2,
        "state": "working",
        "url": "https://github.com/yunohost-apps/mailman_ynh",
        "flags": [ "mailing-list", "lightweight" ]
    },
    "mastodon": {
        "branch": "master",
        "level": 3,
        "state": "inprogress",
        "url": "https://github.com/YunoHost-Apps/mastodon_ynh",
        "flags": [ "social network", "good-UX" ]
    }
}

La fonction principale de la librairie est loads() qui tranforme une chaîne de caractère au format JSON en dictionnaire.

import json

# Ouvrir, lire et interpreter un fichier json
with open("applications.json") as f:
    j = json.loads(f.read())


# Trouver l'état de l'application mailman
j["mailman"]["state"]     # -> "working"

Exemple : requests pour un besoin web simple (bas niveau)

Envoyer une requête HTTP et récuperer la réponse (et potentiellement le contenu d’une page).

import requests

r = requests.get("https://en.wikipedia.org/wiki/Python", timeout=30)

print(r.status_code)    # -> 200 si ça a marché
print(r.text)           # -> Le contenu de la page

Exemple : csv

import csv

# Ouvrir et lire les lignes d'un fichier csv
with open("table.csv") as f:
    table = csv.reader(f, delimiter='|')
    for row in table:
        print(row[1]) # Afficher le 2eme champ
        print(row[3]) # Afficher le 4eme champ

with open("newtable.csv", "w") as f:
    newtable = csv.write(f, delimiter=",")
    newtable.writerow(["Alice", 32, "Lyon"])
    newtable.writerow(["Bob", 29, "Bordeaux"])

Exemple : sys

permet d’interagir / de s’interfacer avec le systeme (librairie système commune à toutes les plateforme)

Par exemple:

import sys

sys.stdout   # La sortie standard du programme
sys.path     # Les chemins depuis lesquels sont chargés les imports
sys.argv     # Tableau des arguments passés en ligne de commande
sys.exit(1)  # Sortir du programme avec un code de retour de 1

Exemple : os

os permet d’interagir avec le système d’exploitation pour réaliser différent type d’action… Certaines étant spécifiques à l’OS en question (Linux, Windows, …)

Quelques exemples :

import os
os.listdir("/etc/")            # Liste les fichiers dans /etc/
os.path.join("/etc", "passwd") # Génère un chemin à partir de plusieurs parties
os.system("touch /etc/toto")   # (à éviter) Execute une commande "brute"

Voir aussi : copie ou suppression de fichiers, modification des permissions, …

Exemple : argparse

• Du vrai parsing d’argument en ligne de commande
• (Un peu long à initialiser mais puissant)

Exemple concurrent: docopt

Sert à la même chose que argparse mais beaucoup plus rapide à utiliser ! Docopt analyse la documentation du module pour deviner les arguments !

"""Naval Fate.

Usage:
  naval_fate.py ship new <name>...
  naval_fate.py ship <name> move <x> <y> [--speed=<kn>]
  naval_fate.py ship shoot <x> <y>
  naval_fate.py mine (set|remove) <x> <y> [--moored | --drifting]
  naval_fate.py (-h | --help)
  naval_fate.py --version

Options:
  -h --help     Show this screen.
  --version     Show version.
  --speed=<kn>  Speed in knots [default: 10].
  --moored      Moored (anchored) mine.
  --drifting    Drifting mine.

"""
from docopt import docopt


if __name__ == '__main__':
    arguments = docopt(__doc__)
    print(arguments)

Ensuite python naval_fate.py ship new monbateau --speed=15 renvoie un dictionnaire d’arguments du type:

{'--drifting': False,    'mine': False,
 '--help': False,        'move': True,
 '--moored': False,      'new': True,
 '--speed': '15',        'remove': False,
 '--version': False,     'set': False,
 '<name>': ['Guardian'], 'ship': True,
 '<x>': '100',           'shoot': False,
 '<y>': '150'}

On peut les utiliser pour paramétrer le programme CLI !

Exemple : subprocess

subprocess peut typiquement être utilisé pour lancer des commandes en parallèle du programme principal et récupérer leur résultat.

out = subprocess.check_output(["echo", "Hello World!"])
print(out)    # -> Affiche 'Hello World'

• check_output : recupère la sortie d’une commande
• check_call : verifie que la commande a bien marché (code de retour ‘0’) ou declenche une exception
• Popen : méthode plus bas niveau

Cf. Partie sur l’execution concurrente en Python

Moar ?

• Debian packages : python-*
• Python package manager : pip

Exemples

• JSON, XML, HTML, YAML, …
• Regular expressions
• Logging, Parsing d’options, …
• Internationalisation
• Templating
• Plots, LDAP, …

Gestionnaire de paquet pip

• Gestionnaire de paquet / modules Python
• PIP : “Pip Install Packages”
• PyPI : Python Package Index : visitez https://pypi.org

(à ne pas confondre avec Pypy un interpreter python écrit en Python)

• Installer un paquet :
  • pip3 install <paquet>
• Rechercher un paquet :
  • pip3 search <motclef>
• Installer une liste de dépendances :
  • pip3 install -r requirements.txt
• Lister les paquets installés
  • pip3 list, pip3 freeze
• Les paquets installés sont dans /usr/lib/python*/dist-packages/

Virtualenv

• Environnement virtuel
• Isoler des paquets / dépendances pour utiliser des versions spécifiques

# La premiere fois :
sudo apt install python3-virtualenv virtualenv

# Creation d'un virtualenv 'venv'
virtualenv -p python3 venv
source venv/bin/activate

# Installation de dependances
pip3 install <une dependance...>
pip3 install <une autre dependance...>


# On développe, on teste, etc....


# Si on a fini et/ou que l'on veut "sortir" du virtualenv
deactivate

Documentation pour toutes les plateformes : https://packaging.python.org/guides/installing-using-pip-and-virtual-environments/

Outils plus récents Pipenv et Conda

Pip et les virtualenv sont les outils classique pour gérer les dépendances en Python mais il existe également de nouvelles solutions moins classique

• Pipenv un outil rassemblant pip et virtualenv pour simplifier le processus de travail.
• Conda un gestionnaire de dépendances multiplateforme.

Installer Pip et Virtualenv sur Windows

• https://matthewhorne.me/how-to-install-python-and-pip-on-windows-10/

Ex.11 Librairies

Les énoncés des exercices suivants peuvent être un peu plus ouverts que les précédents, et ont aussi pour objectifs de vous inciter à explorer la documentation des librairies (ou Internet en général…) pour trouver les outils dont vous avez besoin. Il existe de nombreuse façon de résoudre chaque exercice.

JSON, requests et argparse

11.1.1 : Télécharger le fichier https://app.yunohost.org/apps.json (avec votre navigateur ou wget par exemple). Écrire une fonction qui lit ce fichier, le charge en tant que données json. Écrire une autre fonction capable de filter le dictionnaire pour ne garder que les apps d’un level supérieur à n donné en argument. Écrire une fonction similaire pour le status (working, inprogress, notworking).

11.1.2 : Améliorer le programme précédent pour récupérer la liste directement depuis le programme avec requests. (Ajoutez une instruction pour s’assurer que le code du retour est bien 200 avant de continuer).

11.1.3 : Exporter le résultat d’un filtre (par exemple toutes les applications avec level >= 7) dans un fichier json.

11.1.4 : À l’aide de la librairie argparse, paramétrez le tri à l’aide d’un argument donné en ligne de commande. Par exemple: python3 filtre_apps.py --level 7 exportera dans “result.json” seulement les apps level >= 7.

CSV

11.2.1 : Récupérer le fichier de données CSV auprès du formateur, le lire, et afficher le nom des personnes ayant moins de 24 ans. Pour ce faire, on utilisera la librarie csv.

11.2.2 : Trier les personnes du fichier CSV par année de naissance et enregistrer une nouvelle version de ce fichier avec seulement le nom et l’année de naissance. Pour trier, on pourra utiliser sorted et son argument key.

Random

11.3 : Écrire une fonction jets_de_des(N) qui simule N lancés de dés 6 et retourne le nombre d’occurence de chaque face dans un dictionnaire. Par exemple : {1: 13, 2:16, 3:12, ... }. Calculer ensuite la frequence (nb_occurences / nb_lancés_total) pour chaque face. Testez avec un N grand et en déduire si votre dé virtuel est pipé ou non.

11.4 : Écrire un fonction create_tmp_dir qui choisi un nombre au hasard entre 0 et 100000 puis créer le dossier /tmp/tmp-{lenombre} et retourne le nom du dossier ainsi créé. On pourra utiliser la librairie random pour choisir un nom aléatoire, et os.system ou subprocess.check_call pour créer le dossier.

Interaction avec le systeme de fichier

11.5.1 : Écrire une fonction qui permet de trouver récursivement dans un dossier tous les fichiers modifiés il y a moins de 5 minutes.

11.5.2 : À l’aide d’une deuxième fonction permettant d’afficher les n dernières lignes d’un fichier, afficher les 10 dernières lignes des fichiers récemment modifiés dans /var/log

Interaction avec l’OS

11.6 : Écrire une fonction qui récupère l’utilisation actuelle de la mémoire RAM via la commande free. La fonction retournera une utilisation en pourcent.

11.7 : Écrire une fonction qui renvoie les 3 processus les plus gourmands actuellement en CPU, et les 3 processus les plus gourmands en RAM (avec leur consommation actuelle, chacun en CPU et en RAM)

Documentation

Pour les librairies (et Python en général) :

• docs.python.org
• devdocs.io
• stack overflow …
• doc strings !!

Pour votre code :

• nom de variables, fonctions, argument !!!
• commentaires, doc strings
• gestionnaire de version
• generation de doc automatique ?

Faire du “bon code”

La lisibilité est la priorité numéro 1

Un programme est vivant et évolue. Mieux vaut un programme cassé mais lisible (donc débuggable) qu’un programme qui marche mais incompréhensible (donc fragile et/ou qu’on ne saura pas faire évoluer)

(c.f. Guido van Rossum chez Dropbox)

Autrement dit : la lisibilité pour vous et vos collègues a énormément d’importance pour la maintenabilité et l’évolution du projet

• Keep It Simple
• Sémantique : utiliser des noms de variables et de fonctions concis et pertinents
• Commentaires : lorsque c’est nécessaire, pour démystifier ce qu’il se passe
• Modularité : découper son programme en fonctions qui chacune résolvent un sous-problème
• Couplage faible : garder ses fonctions autant que possibles indépendantes, limiter les effets de bords
• Prendre le temps de refactoriser quand nécessaire
  • si je répète plusieurs fois les mémes opérations, peut-être définir une nouvelle fonction
  • si le contenu d’une variable ou d’une fonction change, peut-être changer son nom
• Ne pas abuser des principes précédents
  • trop d’abstractions tue l’abstraction
  • tout ça viens avec le temps et l’expérience

How to write good code

Conventions de nommages des variables, fonctions et classes

Variables et fonctions en snake case : nom_de_ma_variable

Constantes globales en macro case: NOM_DE_MA_CONSTANTE

Nom de classes en upper camel case : NomDeMaClasse

Syntaxe, PEP8, linters

• Le style d’écriture de python est standardisé via la norme PEP8
• Il existe des “linter” pour détecter le non-respect des conventions (et également certaines erreurs logiques)
  • Par exemple flake8, pylint
• Intégration possible dans vim et autres IDE…
• autopep8 ou black permettent de corriger un bon nombre de problème automatiquement

Ex.12 Outils pour développer

12.1 - Utiliser pip3 pour trouver quelle est le numéro de version du package requests installé

12.2 - Rechercher avec pip3 si les paquets flake8 et autopep8 existent. Installez-les.

12.3 - Utilisez flake8 sur un code que vous avez écrit récemment (disons d’au moins 30 ou 40 lignes !). Étudiez les erreurs et warnings rapportées par flake, et essayer les corriger manuellement. Si certains warnings vous semblent trop aggressif, utiliser --ignore pour spécifier des codes d’erreurs à ignorer.

12.4.1 - Sur un autre code relativement mal formatté, utiliser autopep8 pour tenter d’ajuster automatiquement le formattage du code. Sauvegarder la sortie fournie par autopep8 dans un autre fichier “version 2” et comparer le fichier initial avec le fichier de sortie à l’aide de diff ou de git diff --no-index file1 file2.

12.4.2 - Le nouveau fichier est-il exempt de problèmes d’après flake8 ?

argparse est une librairie python qui va notre permettre de créer simplement des interfaces en ligne de commandes.

import argparse

parser = argparse.ArgumentParser(description="This script does something.")
parser.add_argument("who", help="Who are you ?")
parser.add_argument("many", type=int)
args = parser.parse_args()
for i in range(args.many):
  print("Hello " + args.who)

On crée d’abord un parser avec:

parser = argparse.ArgumentParser(description="This script does something.")

Puis on le remplit avec les informations sur les arguments avec add_argument. On peut indiquer un argument positionnel, en le nommant juste, comme optionnel, avec - ou –

parser.add_argument("who", help="Who are you ?")
parser.add_argument("many", type=int)

argparse traite les données en entrée comme des chaines de caractère si un type n’est pas précisé. On peut le préciser tout simplement avec l’option type=(nom_du_type) On prend ensuite les arguments en entrée et on les parses avec parse_args:

args=parser.parse_args()

On a ainsi nos différents arguments. Ici, args.many, args.who

Reprendre l’exemple précédent et ajouter - devant le nom des argument. Que se passe t’il? Reprendre l’exemple, sauf que cette fois si l’utilisateur ne rentre rien, le programme affiche 3 fois Hello john.

Notes: notre parser est en fait un objet, tout comme ici args. args.many et args.who sont ainsi les attributs de l’objet args. Nous reviendrons sur la notion d’objet plus tard. ///// A supprimer ////

import argparse
parser = argparse.ArgumentParser(description="This script does something.")
parser.add_argument("--who", help="Who are you ?")
parser.add_argument("--many", type=int)
args = parser.parse_args()
for i in range(args.many):
  print("Hello " + args.who)

XML : eXtensible Markup Language

• Format très général pour structurer des informations dans un fichier texte
• Défini et géré par le W3C (Consortium de standardisation et developpement du Web)
• (X)HTML est un cas particulier de XML
• ~historique ?… à tendance à être remplacé par JSON, YAML, bases SQL / noSQL, …

Quelques exemple courants:

• un XML assez standard:

<?xml version="1.0" encoding="UTF-8"?>
<data>
    <apps>
        <app name="mailman" state="working" level="5" />
        <app name="wekan" state="inprogress" level="3" />
        <app name="nextcloud" state="working" level="7" />
        <app name="wordpress" state="working" level="7" />
        <app name="plex" state="notworking" />
    </apps>
</data>

• du html:

<html>
    <head>
        <meta charset="UTF-8">
        <link rel="stylesheet" href="style.css">
        <script src="lib.js"></script>
    </head>
    <body>
        <p class="text-bold">Un morceau de texte</p>
        <p class="text-emph">Un autre paragraphe</p>
    </body>
</html>

• Un documents LibreOffice

<?xml version="1.0" encoding="UTF-8"?>
<office:document-content office:version="1.2">
    [...]
    <office:body>
        <office:text>
            <text:p text:style-name="P1">
            Hello <text:span text:style-name="T1">world!</text:span>
            </text:p>
        </office:text>
    </office:body>
</office:document-content>

Un peu de vocabulaire

<html>
    <head>
        <meta charset="UTF-8">
        <link rel="stylesheet" href="style.css">
        <script src="lib.js"></script>
    </head>
    <body>
        <p class="text-bold">Un morceau de texte</p>
        <p class="text-emph">Un autre paragraphe</p>
    </body>
</html>

• Balises : ouvrantes et fermantes, e.g. <p class="red"> et </p>
• Attributs : par exemple class="red"
• Noeuds éléments : caractérisés et délimités par des balises : head, body, script, p, …
  • peut contenir d’autres noeuds (éléments, texte, …) et donc créer un arbre
• Noeuds texte : e.g. "Un morceau de texte"

XML : Approche DOM v.s. SAX

DOM : Document Object Model

• Lecture et chargement initial de tout le document (peut être lourd pour les gros documents !)
• Puis accès à tous les noeuds de l’arbre (~AST)
• Approche classique et répandue (c.f. Javascript)

SAX : Simple API for XML

• Lecture et analyse “au fur et à mesure”
• Pas besoin de tout charger en mémoire
• Adaptée aux gros documents

ElementTree

• Best of both world ? (Mais moins de fonctionnalités avancées)
• Simple à utiliser comme DOM, peut être aussi rapide que SAX

Quelques exemples de librairies

• xml.tree.ElementTree : ElementTree API, inclue de base dans Python
• lxml : Très complète, support de nombreux standard
• BeautifulSoup : Interface simple, conçu pour parser du HTML contenant des erreurs
• (et pleins d’autres …)

<html>
    <head>
        <meta charset="UTF-8">
        <link rel="stylesheet" href="style.css">
        <script src="lib.js"></script>
    </head>
    <body>
        <p class="text-bold">Un morceau de texte</p>
        <p class="text-emph">Un autre paragraphe</p>
    </body>
</html>

xml.tree.ElementTree

Parser / lire

from xml.etree import ElementTree as ET

root = ET.parse("monfichier.html")
body = root.find("body")

print(body[0])        # --> <Element 'p' at 0x12345>
print(body[0].tag)    # --> p
print(body[0].attrib) # --> {'class': 'text-bold'}
print(body[0].text)   # --> Un morceau de texte
print(list(body[0]))  # --> []  (pas d'elements fils)

# Trouver tout les <p> dans le body
tous_les_p = body.findall("p")

Construire / ecrire

from xml.etree import ElementTree as ET

root = ET.parse("monfichier.html")
body = root.find("body")

# Ajout d'un nouvel element dans <body>
# <p class="text-underline" id="new">Du texte en plus</p>

nouveau_p = ET.SubElement(body, "p", clas="text-underline", id="new")

root.write("monfichier_2.xml")

Parsing itératif avec lxml.etree.iterparse

• ET.parse("fichier.xml") explose la RAM pour les gros fichiers.
• Besoin d’une technique plus efficace
• iterparse fourni un iterateur pour parser au fur et à mesure, qui plus est seulement sur des tags specifiques

from lxml import etree

iterator = etree.iterparse("fichier.xml", tag="p")

for event, element in iterator:
    # [...] traiter l'element

Ça consomme toujours de la RAM … besoin d’un trick en + … c.f. https://stackoverflow.com/questions/12160418

from lxml import etree

def clear_elem_and_ancestors(elem):
    elem.clear()
    for ancestor in elem.xpath('ancestor-or-self::*'):
        while ancestor.getprevious() is not None:
            del ancestor.getparent()[0]

iterator = etree.iterparse("fichier.xml", tag="p")

for event, element in iterator:
    # [...] traiter l'element
    clear_elem_and_ancestors(element)

7.1

def retourner_plus_grand(liste):
    max=liste[0]
    for nombre in liste:
        if nombre>=a:
            max=nombre
    return max

7.2

def plus_grand_mot(liste):
    plus_grand_mot=liste[0]
    for mot in liste:
        if len(mot)>=len(a):
            plus_grand_mot=mot
    return plus_grand_mot

7.3

def somme(liste):
    total=0
    for total in liste:
        total+=nombre
    return total

7.4

def extraire_nom_fichier(path):
    liste=path.split("/") #['usr,'bin,'toto.py']
    nom_du_fichier=list[-1].split(".") #['toto','py']
    return liste[0]

# En un seule ligne
def extraire_nom_fichier_une_ligne(path):
 return path.split("/")[-1].split(".")[0]

7.5.1

example_dict=[{'name': 'Sebastian', 'email': 'Donec.felis.orci@consectetueripsumnunc.edu', 'country': '1979'}, {'name': 'Barclay', 'email': 'aliquet.metus.urna@neceleifend.co.uk', 'country': '2000'}, {'name': 'Vivien', 'email': 'pharetra@a.com', 'country': '1955'}, {'name': 'Britanney', 'email': 'eu.tellus.Phasellus@arcuvelquam.ca', 'country': '1961'}, {'name': 'Reese', 'email': 'tortor.dictum.eu@egestasSed.ca', 'country': '1951'}, {'name': 'Keegan', 'email': 'libero.nec@cursuset.co.uk', 'country': '1998'}, {'name': 'Ezekiel', 'email': 'tempus.mauris.erat@aclibero.org', 'country': '1951'}, {'name': 'Odessa', 'email': 'massa.Quisque.porttitor@felis.net', 'country': '1925'}, {'name': 'Elijah', 'email': 'luctus.vulputate.nisi@nunc.com', 'country': '1963'}, {'name': 'Hilel', 'email': 'lectus.pede.et@aliquetsem.ca', 'country': '1982'}, {'name': 'Callie', 'email': 'et.euismod.et@aliquetmagnaa.net', 'country': '1984'}, {'name': 'India', 'email': 'Duis.sit.amet@Phaselluslibero.com', 'country': '1938'}, {'name': 'Lane', 'email': 'amet@turpis.ca', 'country': '1922'}, {'name': 'Alexis', 'email': 'sagittis.placerat@nibhdolor.net', 'country': '1927'}, {'name': 'Micah', 'email': 'lorem.eget.mollis@SeddictumProin.com', 'country': '1914'}, {'name': 'Rigel', 'email': 'sollicitudin@eratinconsectetuer.org', 'country': '1941'}, {'name': 'Avram', 'email': 'tincidunt.vehicula@vulputate.org', 'country': '1919'}, {'name': 'Dieter', 'email': 'ornare.lectus.justo@Integeridmagna.org', 'country': '1937'}, {'name': 'Sarah', 'email': 'cubilia.Curae.Phasellus@non.net', 'country': '1946'}, {'name': 'Graham', 'email': 'elit.Curabitur.sed@maurisIntegersem.edu', 'country': '1931'}, {'name': 'Daquan', 'email': 'fermentum.convallis.ligula@porttitorinterdum.co.uk', 'country': '1934'}, {'name': 'Nell', 'email': 'purus@lectusconvallisest.org', 'country': '1997'}, {'name': 'Ocean', 'email': 'ut@Nuncquisarcu.net', 'country': '2006'}, {'name': 'Cruz', 'email': 'Aenean.euismod.mauris@idmollisnec.edu', 'country': '1950'}, {'name': 'Hyacinth', 'email': 'amet@Nunc.edu', 'country': '1929'}]

def lire_dict(dict):
    for element in dict:
        print("{} est né.e en {}".format(element["name"],element["country"]))

lire_dico(exemple_dict)

7.5.2

def lire_dict_edu(dict):
    for element in dict:
        if element["email"].split(".")[-1] == 'edu':
            print("{} a pour email {}".format(element["name"],element["email"]))

read_dict_edu(example_dict)

7.6

def compte_lettres(phrase):
    dict={}
    # Pour chaque lettre:
    for lettre in phrase:
    # Si la clef existe (dans ce cas la lettre a déjà été rencontrée) alors on incremente sa valeur de 1.
        if lettre in dict:
            dict[lettre]+=1
    # Si la clef n'existe pas, on la crée et on initialise sa valeur à 1
        else:
            dict[lettre]=1
    return dict

phrase="Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt "
print(compte_lettres(phrase))

7.7

def retourne_pair(liste):
    nouvel_liste=[]
    for nombre in liste:
        if nombre%2==0:
            nouvel_liste.append(element)
    return nouvel_liste

liste_paire=range(11)
print(retourne_pair(liste_paire))

7.8 Cette algorithme de tri classique s’appelle le tri à bulle. Ce n’est pas le plus rapide, mais il est facilement compréhensible.

def tri_a_bulles(tableau):
    for i in range(len(tableau),0,-1):
        for j in range(i-1):
            if tableau[j+1]<tableau[j]:
                tableau[j+1], tableau[j]=tableau[j],tableau[j+1]
    return tableau

7.9 On utlise ici une imbrication de compréhension de lire:

matrice=[[i+j for i in range(5)] for j in range(4)]

7.10

def somme_2(liste):
    if liste:
        #Litéralement ma somme vaut le dernier élément plus la somme de tous les autres éléments moins le dernier
        return liste[-1]+somme_2(liste[:-1])
    else:
        return 0

7.11

def carre():
    i=1
    while True:
        i+=1
        yield i*i

for i in carre():
    if i>200
        break
    print (i)

10.1

def liste_users():
    with open("/etc/passwd","r") as file:
        read_file=file.readlines()
    for element in read_file:
        e=element.rstrip().split(':')
        if e[-1]=="/bin/bash":
            print(e[0])

liste_users()

10.2

def generer_email(prenom,nom):
        modele = """
Bonjour {prenom} !
Voici en pièce jointe les billets pour votre voyage en train vers {destination}.
""".format(prenom=prenom,destination=nom)
        with open("email_{}".format(prenom), "w") as f:
            f.write(modele)

generer_email("Sacha","Rennes")

10.3

def afficher_fichier_no_comment(file,char):
    with open(file) as file_read:
        read_file=file_read.readlines()
    print(read_file)
    for element in read_file:
        if not element.strip() == "" and not element[0]==char:
            print(element,end='')
afficher_fichier_no_comment("test","#")

2.1 - Fichiers, JSON et dictionnaires

• Écrire une fonction qui prends un nom de fichier en argument et retourne le contenu si elle a été capable de le récupérer. Sinon, elle doit déclencher une exception qui explique en français pourquoi elle n’a pas pu.

• Écrire une fonction qui remplace un mot par un autre dans un fichier. On pourra pour cela se servir de une_chaine.replace("mot", "nouveau_mot") qui renvoie une version modifiée de une_chaine en ayant remplacé “mot” par “nouveau mot”.

• Télécharger le fichier https://app.yunohost.org/community.json (avec votre navigateur ou wget par exemple). Écrire une fonction qui lit ce fichier, le charge en tant que données json et renvoie un dictionnaire Python. Écrire une autre fonction capable de filtrer le dictionnaire pour ne garder que les apps d’un level supérieur ou égal à un level n donné en argument. Essayez votre fonction avec le niveau 8.

• Améliorez le programme précédent pour récupérer la liste directement depuis le programme avec requests. Gérer les différentes exceptions qui pourraient se produire (afficher un message en français) : syntaxe json incorrecte, erreur 404, time-out du serveur, erreur SSL

• En utilisant le module ElementTree de Python, charger le fichier countries.xml fourni par le formateur. Boucler sur les différents éléments country et afficher pour chaque élément la valeur du gdppc (PIB par habitant) et le nom des voisins.

• Ajouter un element country pour la France en suivant la même structure.

• Sauvegarder la version modifiée en countries_extended.xml

• Installez lxml grâce à pip3, et récupérez le “gros” fichier XML, copyright.xml à l’adresse https://dl.google.com/rights/books/renewals/google-renewals-20080516.zip. Attention à ne pas tenter d’ouvrir “brutalement” ce fichier avec un éditeur ou avec la méthode utilisée en 1 : cela consommera beaucoup trop de RAM !

• En utilisant des commandes comme head -n 50 copyright.xml, analyser visuellement la structure du fichier d’après ses premières lignes.

• Initialiser un itérateur destiné à itérer sur ce fichier, et en particulier sur les tags Title. Créer une boucle à partir de cet itérateur et afficher tous les titres qui contiennent la chaîne "Pyth". On prendra soin de nettoyer les éléments trouvés avant de passer à chaque nouvelle itération sous peine de remplir la RAM très vite !

• Pour chaque titre trouvé, remonter au parent ‘Record’ pour trouver le ‘Holder Name’ correspondant à ce titre. S’aider du debug VSCode, ipython et/ou ipdb pour tester et expérimenter en interactif.

L’orienté objet est un paradigme de programmation inventé dans les années 80 et popularisé dans les années 90. Aujourd’hui il est incontournable bien qu’il commence aussi à être critiqué.

Il permet d’organiser un programme de façon standard et ainsi d’éviter des erreurs d’architectures comme le spaghetti code

Principe de base

Regrouper les variables et fonctions en entités (“objets”) cohérentes qui appartiennent à des classes

• attributs (les variables décrivant l’état de l’objet)
• méthodes (les fonctions appliqubles à l’objet)

De cette façon on fabrique des sorte types de données spécifique à notre programme utilisables de façon pratique et consistante.

Exemple

Les cercles (classe)

ont un centre, un rayon, une couleur, une épaisseur de trait : ce sont des attributs.

On peut : déplacer le cercle, l’agrandir, calculer son aire, le dessiner sur l’écran : ce sont des méthodes.

Un petit cercle rouge (objet, ou instance)

centre = (3, 5), rayon = 2, couleur = “red”, épaisseur = 0.1

Un grand cercle bleu (autre objet, instance)

centre = (-4, 2), rayon = 6, couleur = “blue”, épaisseur = 1

Exemple en Python

class Cercle:

   def __init__(self, centre, rayon, couleur="black", epaisseur=0.1):
       self.centre = centre
       self.rayon = rayon
       self.couleur = couleur
       self.epaisseur = epaisseur

   def deplacer(self, dx=0, dy=0):
       self.centre = (self.centre[0]+dx, self.centre[1]+dy)


cercle1 = Cercle((3, 5), 2, "red")
cercle2 = Cercle((-4, 2), 6, "blue", epaisseur=1)

cercle1.deplacer(dy=2)
print(cercle1.centre)

• __init__ est le constructeur C’est la fonction qui est appelée à la création de l’objet.

• On instancie un objet en faissant mon_objet = Classe(...) ce qui appelle __init__

• self correspond à l’objet en train d’être manipulé. Il doit être passé en paramètre de toutes les fonctions de la classe (les méthodes)

Les attributs sont les variables internes qui décrivent l’état et régisse le fonctionnement de l’objet.

• self.centre, self.rayon, self.couleur, self.epaisseur sont ici les attributs. Si on lit littéralement la syntaxe python on comprend self.centre comme “le centre de l’objet en cours(le cercle en cours)”

Toutes les fonctions incluses dans la classe sont appelées des méthodes.

• __init__ et deplacer sont des méthodes. Elles agissent généralement sur les attributs de l’objet mais pas nécessairement.

Les attributs et méthodes de la classe sont “dans” chaque instance d’objet (ici chaque cercle). On dit que la classe est un namespace (ou espace de nom). Chaque variable centre est isolée dans son cercle et on peut donc réutiliser plusieurs fois le nom centre pour chaque cercle. Par contre pour y accéder on doit préciser le cercle concerné avec la syntaxe cercle1.centre.

• De même on utilise les methodes en faisant un_objet.la_methode(...)

Attention à l’indentation !!

Spaghetti code, variables globales et refactoring

Lorsqu’on enchaine simplement des instructions sans trop de structure dans un programme on arrive vite à quelque chose d’assez imprévisible et ingérable.

On commence généralement à définir des variables globales accessibles partout pour maintenir l’état de notre programme. Plusieurs fonctions viennent modifier de façon concurrente ces variables globales (pensez au score dans un jeu par exemple) pouvant mener à des bugs complexes.

On arrive aussi à beaucoup de code dupliqué et il devient très difficile dans ce contexte de refactorer un programme:

• dès qu’on tire un spaghetti tout casse
• dès qu’on veut changer un endroit il faut modifier beaucoup de choses
• la compréhension du programme devient difficile pour le développeur initial et encore plus pour ses collègues.

On peut voir la programmation orientée objet comme une façon d’éviter le code spaghetti.

Intérets de la POO

La POO est critique pour garder un code structuré et compréhensible quand la complexité d’un projet augmente.

• Rassembler ce qui va ensemble pour s’y retrouver
• Maintenir les variables isolées à l’intérieur d’un “scope” pour évitées qu’elles ne soient modifiée n’importe quand et n’importe comment et qu’il y ai des conflits de nom.
• Fournir une façon d’architecturer un programme que tout le monde connait à peu près
• Fournir un moyen efficace de programmer en évitant la répétition et favorisant la réutilisation
• Créer des “boîtes noires” utilisables sans connaître leur fonctionnement interne (bien et pas bien à la fois). C’est à dire une façon de se répartir le travail entre développeurs (chacun sa boîte qu’on maîtrise).

DRY don’t repeat yourself et couplage

La POO permet d’appliquer le principe DRY -> identifier ce qui se ressemble et le rassembler dans une méthode ou une classe.

Cela permet ensuite de modifier le code à un seul endroit pour tout changer -> puissant.

Il s’agit plus d’un ideal que d’un principe. Il ne faut pas l’appliquer à outrance parfois un peu de répétition est mieux car plus simple.

Si on factorise tout en POO on arrive souvent à un code fortement coupler qui empêche le refactoring et le programme finit par devenir fragile.

À retenir

• __init__ est le constructeur
• __init__ et deplacer sont des méthodes
• self correspond à l’objet en train d’être manipulé
• Toutes les méthodes ont au moins self comme premier argument
• On utilise les methodes en faisant un_objet.la_methode(...)
• self.centre, self.rayon, self.couleur, self.epaisseur sont des attributs
• On instancie un objet en faissant mon_objet = Classe(...)

Héritage

Une classe peut hériter d’une autre pour étendre ses fonctionnalités. Inversement, cela permet de factoriser plusieurs classes ayant des fonctionnalités communes.

Par exemple, les cercles, les carrés et les étoiles sont trois types de figures géométriques.

En tant que figure géométriques, elles ont toutes un centre, une couleur et une épaisseur utilisés pour le dessin. On peut les déplacer, et on peut calculer leur aire.

• L’héritage permet d’ordonner des objets proches en les apparentant pour s’y retrouver.
• Il permet également de factoriser du code en repérant des comportements génériques utilisés dans plusieurs contextes et en les mettant dans un parent commun.

class FigureGeometrique:

    def __init__(self, centre, couleur="black", epaisseur=0.1):
        raise NotImplementedError("La classe fille doit implémenter cette fonction!")
        self.centre = centre
        self.couleur = couleur
        self.epaisseur = epaisseur

    def deplacer(self, dx=0, dy=0):
        self.centre = (self.centre[0]+dx, self.centre[1]+dy)

    def aire(self):
        raise NotImplementedError("La classe fille doit implémenter cette fonction!")

class Cercle(FigureGeometrique):

    def __init__(self, centre, rayon, couleur="black", epaisseur=0.1):
        self.rayon = rayon
        super().__init__(centre, couleur, epaisseur)

    def aire(self):
        return 3.1415 * self.rayon * self.rayon

class Carre(FigureGeometrique):

    def __init__(self, centre, cote, couleur="black", epaisseur=0.1):
        self.cote = cote
        super().__init__(centre, couleur, epaisseur)

    def aire(self):
        return self.cote ** 2


cercle_rouge = Cercle((3, 5), 2, "red")
carre_vert  = Carre((5, -1), 3, "green", epaisseur=0.2)

cercle_rouge.deplacer(dy=2)
carre_vert.deplacer(dx=-3)

print(carre_vert.centre) # -> affiche (2, -1)
print(carre_vert.aire()) # -> affiche 9

• Les cercles et les carrés “descendent” ou “héritent” de la classe FigureGeometrique avec la syntaxe class Carre(FigureGeometrique).

• La méthode deplacer de la classe mère est disponible automatiquement dans les classes filles

Ainsi pour factoriser du code on peut repèrer un comportement commun à plusieurs éléments de notre programme et on créé une classe mère avec une méthode exprimant ce comportement de façon générique. Tous les classes fille pourront utiliser ce comportement. Si on le change plus tard il sera changé dans tout le programme (puissant pour refactoriser le code)

Cependant il est rare qu’un comportement soit exactement identique entre deux classes. On veut souvent changer légèrement ce comportement selon la classe utilisée. Pour cela on utilise le polymorphisme.

Polymorphisme

Surcharge de fonction

Dans le cas de l’aire de nos figures, chaque figure doit pouvoir calculer son aire mais le calcul est différent pour chaque type de figure concrête.

• On définit une méthode abstraite aire dans la classe mère pour indiquer que chaque figure a une méthode aire. Comme une figure en général n’a pas de calcul d’aire la méthode abstraite déclenche une exception (Utilisez ici NotImplementedError() qui est faite pour ça)

• On redéfinit la méthode aire dans chaque classe fille. La méthode aire fille écrase ou surcharge celle de la classe mère et sera appelée à la place de celle-ci dès qu’on veut l’aire d’une figure géométrique.

Découper le travail en méthode mère et fille avec super().methode()

Souvent on veut quand même utiliser la méthode de la classe même pour faire une partie du travail (commun à toute les classes filles) et ensuite spécialiser le travail en ajoutant des actions suplémentaires dans la méthode fille qui surcharge la méthode mère. A cause de la surcharge la méthode mère n’est pas du tout appelée automatiquement donc il faut le faire “manuellement”.

Exemple ci-dessus: pour créer un carré:

• on appelle d’abord le constructeur de la classe mère qui initialise centre, couleur et epaisseur avec super().__init__()
• Puis on initialise cote qui est un attribut du carré (mais pas du cercle donc pas dans le constructeur général)

De façon générale super() renvoie une instance de la classe mère.

Classe Abstraite

Une classe abstraite est une classe dont on ne peut pas créer d’instance. Elle est simplement là pour définir un modèle minimal que toutes les classes fille doivent suivre (et étendre).

En Python on créé généralement une classe abstraite en levant l’exception NotImplementedError dans le constructeur __init__.

Travailler avec la classe mère

On parle de polymorphisme quand on utilise la classe abstraite pour gérer uniformément plusieurs type d’objets de classe différente et qu’on laisse le langage choisir le comportement en fonction du contexte.

Par exemple on peut faire une liste de FigureGeometrique de différents types et afficher les aire de chacune. Python devinera automatiquement quelle méthode appeler :

formes = [Cercle((3, 5), 2, "red"),
          Carre((5, -1), 3, "green"),
          Cercle((-2, 4), 5, "yellow"),
          Carre((4, -2), 2, "purple")]

for forme in formes:
    print(forme.aire())

(c.f. aussi autre exemple sur stack overflow)

Le polymorphisme est puissant car il permet d’économiser beaucoup de if et autre branchements:

On aurait pu écrire l’exemple précédent avec des if isinstance(figure, Cercle): par exemple mais cela aurait été beaucoup moins élégant.

À retenir

• class Cercle(FigureGeometrique) fais hériter Cercle de FigureGeometrique
• super().__init__(...) permet d’appeler le constructeur de la classe mère
• Les classes filles disposent des méthodes de la classe mère mais peuvent les surcharger (c.f. exemple avec aire)
• super().une_methode(...) permet d’appeler une_methode telle que définie dans la classe mère.
• isinstance verifie l’heritage ! isinstance(cercle_rouge, FigureGeometrique) vaut True !

Tester la classe pour s’adapter

Souvent pour adapter le comportement d’un programme on veut savoir de quel type est un objet:

• isinstance verifie l’heritage ! isinstance(cercle_rouge, FigureGeometrique) vaut True !

D’abord quelques astuces

• dir(un_objet) : listes tous les attributs / methodes d’un objet (ou module)
• Il existe aussi un_objet.__dict__
• MaClasse.__subclasses__() : lister toutes les classes filles d’une classe

Attributs ‘statiques’ (partagés par tous les objets d’une classe)

Les attributs qui sont définits dans le corps de la classe et non dans le constructeurs sont statiques en python. C’est à dire que leur valeur est commune à toutes les instances de la classe en cours d’utilisation dans le programme. Cela peut être très pratique pour maintenir une vision globale de l’état du programme de façon sécurisée.

class FormeGeometrique():

    nb_instances = 0

    def __init__(self):
        FormeGeometrique.nb_instances += 1

forme1 = FormeGeometrique()
forme2 = FormeGeometrique()
forme3 = FormeGeometrique()

print(FormeGeometrique.nb_instances)
# -> affiche 3

Méthodes statiques et méthodes de classe

… Sont deux types de méthodes rattachées à une classe mais non à une instance de la classe (un objet). On les fabrique en ajoutant les décorateurs @staticmethod ou @classmethod sur une méthode de la classe.

La méthode statique est complètement indépendante de la classe même si rangée à l’intérieur alors que la méthode de classe récupère implicitement sa classe comme premier argument ce qui permet de construire des objet de la classe dans le corps de la méthode

Exemple d’utilisation d’un méthode de classe

class MaCollectionDeLettre: # Réimplétation de String

    def __init__(self, astring): # Build an object from a string
      self._string = astring

    @classmethod
    def build_from_list(cls, alist): # Alternative constructor to build from a list of lettres
      x = cls('') # L'argument implicite cls permet de construire un objet de la classe
      x._string = ','.join(str(s) for s in alist)
      return x

L’encapsulation

Nous avons évoqué dans le cours 13 qu’un des intérêts de la POO est de sécuriser les variables dans un contexte isolé pour éviter qu’elles soient accédées à tort et à travers par différents programmeurs ce qui a tendance à créer des bugs mythiques.

Pour éviter cela on essaye au maximum d’encapsuler les attributs et les méthodes internes qui servent à faire fonctionner une classe pour éviter que les utilisateurs de la classe (ignorants son fonctionnement) puissent pas les appeler directement et “casser” le fonctionnement de la classe.

On parle d’attributs et méthodes privés quand ils sont internes et inaccessibles.

En Python les attributs et méthodes d’un objet sont “publiques” par défaut : on peut y accéder quand on veut et donc il faut donc une façon de pouvoir interdire leur usage:

• On utilise un underscore _ devant le nom de l’attribut ou méthode pout indiquer qu’il est privé et ne doit pas être utilisé.

Exemple: self._valeurinterne = 50 ou def _mamethodeprivee(self, arg): ...

En réalité l’attribut/méthode est toujours accessible, il s’agit d’une convention mais il faut la respecter !! Par défaut les editeurs de code vous masqueront les elements privés lors de l’autocomplétion par exemple.

Accesseurs (getters) et mutateurs (setters)

Même lorsque qu’un attribut d’objet devrait être accessible à l’utilisateur (par exemple le rayon d’un cercle), on voudrait pouvoir contrôler l’accès à cet attribut pour que tout ce passe bien.

Par exemple éviter que l’utilisateur puisse définir un rayon négatif !!

Pour cela on créé des attributs privés et on définit des méthodes “publique”

On veut donc généralement pouvoir y donner accès à l’utilisateur de la classe selon certaines conditions.

Pour cela un définit une méthode d’accès (getter/accesseur) qui décrit comment récupérer la valeur ou une méthode de modification (setter/mutateur) qui contrôle comment on peut modifier la valeur (et qui vous envoie balader si vous définissez un rayon négatif).

Exemple (non pythonique !)

class Cercle:

   def __init__(self, centre, rayon, couleur="black", epaisseur=0.1):
       self.centre = centre
       self._rayon = rayon
       self._couleur = couleur

    def get_couleur(self):
        print("on accède à la couleur")
        return self._couleur

    def set_rayon(self, rayon)
        assert rayon > 0, "Le rayon doit être supérieur à 0 !"
        self._rayon = rayon



cercle1 = Cercle((3, 5), 2, "red")
cercle1.get_couleur()
cercle1.set_rayon(1)
cercle1.set_rayon(-1) # Erreur

Cependant en Python on ne fait généralement pas directement comme dans cet exemple !

Des attributs “dynamiques” avec @property

Le décorateur @property ajouté à une méthode permet de l’appeler comme un attribut (sans parenthèses)

class Carre(FigureGeometrique):

    # [ ... ]

    @property
    def aire(self):
        return self.cote * self.cote


carre_vert  = Carre((5, -1), 3, "green", epaisseur=0.2)
print(carre_vert.aire) # N.B. : plus besoin de mettre de parenthèse ! Se comporte comme un attribut

Autre exemple avec @property

class Facture():

    def __init__(self, total):
        self.montant_total = total
        self.montant_deja_paye = 0

    @property
    def montant_restant_a_payer(self):
        return montant_total - montant_deja_paye


ma_facture = Facture(45)
ma_facture.montant_deja_paye += 7

print("Il reste %s à payer" % ma_facture.montant_restant_a_payer)
# -> Il reste 38 à payer

La façon pythonique de faire des getters et setters en python est donc la suivante:

        @property
        def toto(self):
            return self.__toto

        @toto.setter
        def toto(self, value):
            self.__toto = value   # ... ou tout autre traitement

On peut ensuite accéder et modifier l’attribut toto de manière transparente :

monobjet = Objet()

monobjet.toto = "nouvelle_valeur"
print(monobjet.toto)

Enregistrer des objets avec pickle

pickle permet de “sérialiser” et “déserialiser” des objets (ou de manière générale des structure de données) en un flux binaire (!= texte).

Sauvegarde

import pickle

ma_facture = Facture(45)

f = open("save.bin", "wb")   # the 'b' in 'wb' is important !
pickle.dump(ma_facture, f)

Puis recuperation

import pickle

f = open("save.bin", "rb")
ma_facture = pickle.load(f)

Un exemple courant de POO : les ORM (Object Relationnal Mapper)

Rappels (?) sur SQL

• Base de données : stocker des informations en masse et de manière efficace
• On manipule des tables (des lignes, des colonnes) …
• Les colonnes sont fortement typées et on peut poser des contraintes (unicité, …)
• Relations entres les tables, écritures concurrentes, …
• Exemple de requête :

# Create a table
CREATE TABLE members (username text, email text, memberSince date, balance real)

# Add a record
INSERT INTO members VALUES ('alice', 'alice@gmail.com', '2017-11-05', 35.14)

# Find records
SELECT * FROM members WHERE balance>0;

Orienté objet : ORM

SQL “brut” en Python

import sqlite3
conn = sqlite3.connect('example.db')

c = conn.cursor()

# Create a table
c.execute('''CREATE TABLE members
             (username text, email text, memberSince date, balance real)''')

# Add a record
c.execute("INSERT INTO members VALUES ('alice', 'alice@gmail.com', '2017-11-05', 35.14)")

# Save (commit) the changes and close the connection
conn.commit()
conn.close()

Définition - Object Relational Mapping

• Sauvegarder et charger des objets dans une base de donnée de type SQL de manière “transparente”
• Simplifie énormément l’interface entre Python et SQL
  • Python <-> base SQL
  • classes (ou modèle) <-> tables
  • objets <-> lignes
  • attributs <-> colonnes
• Gère aussi la construction et execution des requêtes (query)
• Syntaxe spéciale pour définir les types et les contraintes (en fonction de la lib utilisée)
• Librairie populaire et efficace : SQLAlchemy (on utilisera la surcouche ActiveAlchemy)

Exemple de classe / modèle

from active_alchemy import ActiveAlchemy

db = ActiveAlchemy('sqlite:///members.db')

class Member(db.Model):
	username    = db.Column(db.String(25), nullable=False, unique=True)
	email       = db.Column(db.String(50), nullable=True)
	memberSince = db.Column(db.Date,       nullable=False)
    balance     = db.Column(db.Float,      nullable=False, default=0.0)
    active      = db.Column(db.Boolean,    nullable=False, default=True)