Repozitorijs ir arhivēts. Tam var aplūkot failus un to var klonēt, bet nevar iesūtīt jaunas izmaiņas, kā arī atvērt jaunas problēmas/izmaiņu pieprasījumus.

11 KiB

Neapstrādāts Vainot Vēsture

% Programmation avec Python (chapitre 3) % Dimitri Merejkowsky

\center \huge None

Exprimer l’absence

Exemple: clé non présente dans un dictionnaire:

>>> scores = { "Anne": 42, "Bernard": 5 }
>>> score1 = scores.get("Anne")
>>> score1
42
>>> score2 = scores.get("Sophie")
>>> score2
<rien>

En réalité, score2 a bien une valeur: None.

L’interpréteur n’affiche rien quand la valeur est None

None est ambigu

None est falsy, tout comme 0, False et les listes vides:

element = dictionnaire.get(clé)
if not element:
    ...

Mais ici, comment faire la différence entre:

la clé existe et vaut None
la clé existe et est falsy
la clé n’existe pas ?

Solution 1: tester l’appartenance

Avec in:

if clé in dictionnaire:
    # La clé existe, pas d'erreur
    valeur = dictionnaire[clé]

Solution 2: tester None

Avec is:

>>> scores = { "Anne": 42, "Bernard": 5 }
>>> score1 = scores.get("Anne")
>>> score1 is None
False
>>> score2 = scores.get("Sophie")
>>> score2 is None
True

Retourner None

None est aussi la valeur par défaut lorsqu’il n’y a pas de return dans le corps de la fonction:

>>> def ne_retourne_rien(a, b):
>>>     c = a + b

>>> résultat = ne_retourne_rien(3, 2)
>>> résultat is None
True

Retourner None (2)

On dit aussi que la fonction est une procédure.

On a déjà écrit des procédures: dans pendu.py, display_hint() et main() ne retournaient rien.

Retourner None au autre chose

def trouve_dans_liste1(liste, element):
    if element in list:
        return liste.index(element)


def trouve_dans_liste2(liste, element):
    if element in list:
        return liste.index(element)
    else:
        return None

\vfill

Les deux fonctions font la même chose : trouve_dans_liste2 est simplement plus explicite.

Types optionnels

def trouve_dans_liste(liste, element):
    if element in list:
        return liste.index(element)
    else:
        return None

On dit aussi que le type de retour de trouve_dans_liste est optionnel.

\centering \huge Retour sur les listes

Méthodes

fruits = ["pomme", "banane"]
fruits.append("orange")

Quand on écrit fruits.append("orange"), on peut voir append() comme une “fonction” qui prendrait fruits en argument implicite (avant le .), et orange en argument explicite.

On appelle ce genre de fonction une méthode.

clear()

Pour vider une liste:

>>> fruits = ["pomme", "banane"]
>>> fruits.clear()
>>> fruits
[]

Notez que la méthode clear() ne renvoie rien! La liste est modifiée sur place.

extend()

Pour concaténer des listes:

>>> fruits = ["pomme", "banane"]
>>> fruits.extend(["orange", "abricot"])
>>> fruits
['pomme', 'banane', 'orange', 'abricot']

\vfill

Peut aussi s'écrire +=

>>> nombres = [1, 2]
>>> nombres += [3, 4]
>>> nombres
[1, 2, 3, 4]

pop()

On a vu la méthode pop() pour les dictionnaires, mais elle existe aussi pour les listes:

\vfill

>>> fruits = ["pomme", "banane"]
>>> fruits.pop()  # Retourne l'élément
'pomme'
>>> fruits  # Et modifie la liste
["banane"]

pop() sur liste vide

>>> liste_vide = list()
>>> liste_vide.pop()
IndexError

index()

Pour récupérer la position d’un élément:

>>> fruits = ["pomme", "banane"]
>>> fruits.index("banane")
>>> 1
>>> fruits.index("citron")
>> ValueError

count()

Pour compter le nombre d’occurrences d’un élément

>>> fruits = ["pomme", "banane", "pomme", "poire"]
>>> fruits.count("pomme")
2
>>> fruits.count("poire")
1
>>> fruits.count("citron")
0

Indexer des listes

Rappel:

>>> lettres = ["a", "b", "c", "d", "e"]
>>> lettres[0]  # ça commence à zéro
"a"
>>> lettres[4]
"e"

Mais on peut aussi compter à l’envers:

>>> lettres[-1]
"e"
>>> lettres[-2]
"d"

Trancher des listes

Ou “faire des slices”, ou “slicer”.

>>> lettres = ["a", "b", "c", "d", "e"]
>>> lettres[1:3]  # début (inclus), fin (non-inclus)
['b', 'c']
>>> lettres[:3] # début implicite
['a', 'b', 'c']
>>> lettres[3:] # fin implicite
['d', 'e']
>>> lettres[1:-2]  # fin négative
['b', 'c']

\centering \huge Retour sur les strings

Rappel

On a vu que les strings étaient “presque” des liste de caractères.

Par exemple, on peut itérer sur les lettres d’un mot avec: for lettre in mot.

index() et count() marchent aussi

>>> message = "Bonjour, monde !"
>>> message.index("B")
0
>>> message.count("o")
3

Trancher des chaînes de caractères

On peu aussi slicer des strings:

\vfill

>>> message = "Bonjour, monde !"
>>> message[1:4]
'onj'
>>> message[:7]
'Bonjour'
>>> message[9:-2]
'monde'

Les strings sont immuables

Mais on ne peut pas modifier une string “sur place”.

>>> message = "Bonjour, monde !"
>>> message[-1] = "?"
TypeError

>>> message = "Bonjour, monde !"
>>> message.clear()
AttributeError

\centering \huge La ligne de commande

Schéma

Entrée / sortie

3 canaux:

Une entrée qu’on peut lire (stdin)
Deux sorties:
- Sortie normale (ou standard) (stdout)
- Sortie d’erreur (stdout)

Accès en Python

Pour lire stdin: input()
Pour écrire dans stdout: print()
Pour écrire dans stderr: pas de fonction native

Accès en Python (2)

Rajouter import sys en haut du fichier, puis:

sys.stdin.read()
sys.stout.write()
sys.stderr.write()

On peut aussi utiliser:

print("erreur", file=sys.stderr)

Accès depuis l’invite de commande

On dit aussi shell, ou CLI (pour command line interface).

stdin: Taper quand le shell vous laisse la main, finir par ‘entrée’
stdout et stderr sont affichés en même temps pas défaut

Rediriger stdout

Linux , macOS, Windows:

python3 fichier.py > output.txt

stdout sera écrit dans output.txt, et seul stderr sera visible.

Code de retour

0 quand tout va bien
un autre entier quand quelque chose va mal

\vfill

Toutes les familles heureuses se ressemblent, mais chaque famille malheureuse l’est à sa façon.

Tolstoï

Code de retour

Les valeurs d’erreur possibles sont en général présentes dans la documentation.

Note: ne pas retourner 0 en cas d’erreur, même minime, et même si un message a été affiché.

C’est important pour pourvoir composer plusieurs programmes (on y reviendra).

Afficher le code retour depuis le shell

# Linux, macOS
$ python3 code.py
$ echo $?
0

# Windows
> python3 code.py
> echo %ERRORLEVEL%
0

Gestion du code de retour en Python

Par défaut, le code de retour est 0.

On peut terminer le programme avec sys.exit() et un numéro:

import sys

def fait_quelque_chose():
     if erreur:
         sys.exit(1)

Note: dans un vrai programme, veillez à construire et afficher un message utile!

Gestion du code de retour en Python (2)

sys.exit(0) pour terminer immédiatement et sans erreur.

import sys

def antivirus():
    problèmes = cherche_problèmes()

    if not problèmes:
        print("Aucun problème trouvé")
        sys.exit(0)

    for problème in problèmes:
        # traite chaque problème un à un
        ...

Gestion du code de retour en Python - un raccourci

On peut passer le message d’erreur directement à sys.exit() avec une string au lieu d’un numéro:

if erreur:
    sys.exit("Une erreur est survenue")

Les arguments d’un programme

Pour lancer un programme, on tape son nom, suivi de mots séparés pas des espaces.

En Python, ça donne

python3 fichier.py arg1 arg2

Accès aux arguments en Python

import sys
sys.argv

sys.argv est une liste, et son premier argument est toujours le nom du fichier exécuté.

Exemple

# Dans foo.py
import sys
print("Fichier source:", sys.argv[0])
print("Reste des arguments:", sys.argv[1:])

\vfill

$ python3 foo.py un deux
Fichier source: foo.py
Reste des arguments: ['un', 'deux']

\center \huge Cas pratique

Squelette

Décodeur de noms d’aéroports

Lire un fichier avec les codes et les noms associés
En faire un dictionnaire
Utiliser le premier argument comme nom de code
Afficher le nom complet de l’aéeroport, ou une erreur s’il est inconnu.

Différentes approches

Bottom-up (approche ascendante)
Top-Bottom (approche descendante)

Approches bottom-up

Utilisé pour le pendu:

construire des blocs élémentaires (les petites fonctions has_won, display_hint, etc...)
les assembler pour faire un tout plus “haut niveau” (le corps de la fonction main()

Approche top-down

Essayons de partir du plus “haut niveau” et de “descendre” vers les blocs élémentaires

Code

def main():
    dico = fabrique_dico()
    code = lire_code()
    nom = trouve_code(code, dico)
    if nom:
        print(nom)
    else:
        affiche_erreur(code)

main()

On a fait comme si le code dont on avait besoin était déjà écrit :)

lire_code()

import sys

def lire_code():
    if len(sys.argv) < 2:
        print(
            "Pas assez d'arguments",
            file=sys.stderr
        )
        sys.exit(1)
    argument = sys.argv[1]
    # On accepte `cdg` ou `CDG`.
    code = argument.upper()
    return code

fabrique_dico()

Le fichier airports.txt ressemble à ça:

CDG Paris-Charles de Gaulle
ORY Paris-Orly
NCE Nice-Côte d'Azur
...

Téléchargez-le ici:

\url{https://raw.githubusercontent.com/E2L/cours-python/master/sources/airports.txt}

Clique droit / Enregistrer sous / airports.txt

fabrique_dico() - 2

def fabrique_dico():
    dico = dict()
    fichier = open("airports.txt", "r")
    contenu = fichier.read()
    fichier.close()

    lignes = contenu.splitlines()
    for ligne in lignes:
        code = ligne[0:3]
        nom = ligne[4:]
        dico[code] = nom
    return dico

trouve_code()

def trouve_code(code, dico):
    if code in dico:
        return dico[code]

\vfill

Notez le return None implicite!

affiche_erreur()

def affiche_erreur(code):
    print(
        "Code:", code,
        "non trouvé",
        file=sys.stderr
    )
    sys.exit(2)

Notes:

on affiche le code qu’on a pas trouvé (c’est utile de l’avoir dans le message)
valeur d’erreur différente du cas où il n’y avait pas assez d’arguments

Rappel du `main()`

def main():
    dico = fabrique_dico()
    code = lire_code()
    nom = trouve_code(code, dico)
    if nom:
        print(nom)
    else:
        affiche_erreur(code)

main()

\centering \huge Démo

Place au débat

Quelle approche avez-vous préférée entre bottom-up et top-down?

Pourquoi?

11 KiB Neapstrādāts Vainot Vēsture

Exprimer l’absence

None est ambigu

Solution 1: tester l’appartenance

Solution 2: tester None

Retourner None

Retourner None (2)

Retourner None au autre chose

Types optionnels

Méthodes

clear()

extend()

pop()

pop() sur liste vide

index()

count()

Indexer des listes

Trancher des listes

Rappel

index() et count() marchent aussi

Trancher des chaînes de caractères

Les strings sont immuables

Schéma

Entrée / sortie

Accès en Python

Accès en Python (2)

Accès depuis l’invite de commande

Rediriger stdout

Code de retour

Code de retour

Afficher le code retour depuis le shell

Gestion du code de retour en Python

Gestion du code de retour en Python (2)

Gestion du code de retour en Python - un raccourci

Les arguments d’un programme

Accès aux arguments en Python

Exemple

Squelette

Différentes approches

Approches bottom-up

Approche top-down

Code

lire_code()

fabrique_dico()

fabrique_dico() - 2

trouve_code()

affiche_erreur()

Rappel du main()

Place au débat

11 KiB

Neapstrādāts Vainot Vēsture

Rappel du `main()`