Sunday, March 22, 2015

Comment suivre ce tutoriel

Prérequis

Nous supposerons ici:

que vous avez réussi à installer Python et Pyscripter, ou tout autre environnement de développement intégré,
que vous avez bien compris la différence entre interpréteur et éditeur.

Sinon vous pouvez allez voir les paragraphes Installation, L’interpréteur et L’éditeur.

Sections proposées en deuxième lecture

Ce tutoriel s’adressant à un large public, nous avons aussi voulu y inclure des notions assez avancées. Vous pourrez les passer en première lecture si vous ne vous sentez pas assez solide, et y revenir lors d’une deuxième lecture. Vous pourrez aussi les lire directement bien sûr, si vous en sentez la curiosité et la force.

Les passages en questions seront indiqués ainsi:

Pour aller plus loin

Notion moins facile, à lire peut-être dans un second temps.

Créer son propre aide-mémoire

Que vous soyez enseignant ou élève (ou ni l’un ni l’autre mais que vous voulez profiter de ces pages), nous vous conseillons de suivre ce tutoriel en gardant une trace des commandes «qui marchent».

En effet, vous serez content plus tard de retrouver les quelques lignes que vous aviez comprises, mais que vous n’avez pas pu retenir par cœur. D’un autre côté, purement scolaire cette fois-ci, votre professeur pourra suivre votre progression au travers des fichiers que vous aurez enregistrés au fur et à mesure.

La méthode que nous préconisons est la suivante: chaque bout de code proposé dans le tutoriel devra être:

testé directement dans l’interpréteur,
rédigé dans l’éditeur (vous aurez sûrement besoin de l’instruction print pour afficher un résultat), puis testé,
testé à nouveau dans l’interpréteur après une ou plusieurs modifications (légères ou importantes, à vous de faire preuve de créativité),
à nouveau rédigé et testé dans l’éditeur avec les modifications de l’étape précédente.

Exemple

Un exemple basé sur la partie L’interpréteur où l’on trouve:

>>> 2+3*5
17

Note

C’est le moment d’ouvrir votre environnement de développement (PyScripter par exemple) et de suivre ces quatre étapes au fur et à mesure!

Première étape, le test dans l’interpréteur. On y tape 2+3*5 puis Entrée. On contrôle que Python répond bien 17.

Deuxième étape, on rédige ce test dans l’éditeur. On peut y taper simplement:

print(2+3*5)

Notez que c’est simplement ce que propose le tutoriel (2+3*5) à l’intérieur des parenthèses d’un print (Python 2.x n’a pas besoin des parenthèses).

L’exécution du programme donnera:

On peut aussi y taper quelque chose de plus complet:

# Test d’une opération arithmétique simple.
print("2+3*5 donne:")
print(2+3*5)

Ici on a commenté ce que l’on faisait à l’aide du symbole # et on a embelli l’affichage en rajoutant un print qui montre ce que l’on a demandé de faire à Python.

N’oubliez pas d’exécuter votre programme pour le tester.

Troisième étape, on tente une modification simple dans l’interpréteur, puis une autre, puis encore une autre plus élaborée…

>>> 2+3*5+1
18
>>> 2 + 3*5 + 1
18
>>> 2 + 3*5 - 5*(12 - 7)
-8

Quatrième étape, on rédige les trouvailles de l’étape précédente dans l’éditeur, et on les teste.

N’oubliez pas d’enregistrer votre fichier, si possible avec un nom significatif. Vous pourrez ainsi retrouver facilement un morceau de code dont vous aurez besoin, et qui fonctionne!

Cela peut par exemple donner:

# Test d’une opération arithmétique simple.
print("2+3*5 donne:")
print(2+3*5)

print("Les espaces sont possibles pour mieux présenter un calcul.")
print("2 + 3*5 + 1 donne aussi:")
print(2 + 3*5 + 1)

# À vous pour 2 + 3*5 - 5*(12 - 7) !!!

Première utilisation

L’interpréteur

L’interpréteur, on le reconnait facilement. C’est lui qui contient le triple chevron >>> qui est l’invite de Python (prompt en anglais) et qui signifie que Python attend une commande. L’esprit d’utilisation de l’interpréteur est un peu le même que celui d’une calculatrice.

>>> 2 + 3 * 5
17

On remarque au passage que la priorité des opérations est bien respectée.

Pour écrire des commentaires, il faut commencer par le caractère #.

>>> # une ligne qui ne fait rien

Bon, mettre un commentaire dans l’interpréteur n’a pas beaucoup d’intérêt, mais cela peut s’avérer utile dans l’écriture d’un script dans un éditeur de texte.

L’éditeur

On peut y écrire des scripts, c’est-à-dire des programmes petits ou grands. Pour l’instant contentons-nous de quelque chose de très simple :

print(4.6 / 2)

Ce tout petit script permet l’affichage du quotient de 4,6 par 2.

Installation

De quoi a-t-on besoin ?

D’une version de Python. Il en existe plusieurs. Attention, les anciennes versions en 2.x sont incompatibles avec les plus récentes en 3.x.
Et au minimum, d’un éditeur de texte.

Mais pour débuter, le plus simple est d’utiliser un environnement de développement intégré :

Sous linux

Cela peut être :

IDLE (fourni avec certaines distributions de Python),
Gedit avec un greffon Python,
DrPython (disponible aussi sous windows).

Sous windows

Cela peut aussi être IDLE ou bien Pyscripter. Mais inutile de télécharger ce dernier séparément puisqu’il est inclus dans le pack Portable Python. L’installatation de ce pack est très simple et comprend une version récente de Python ou des versions plus anciennes (2.x). Pour télécharger Portable Python, allez sur cette page de téléchargement puis une fois la version choisie, suivez un des liens HTTP ou FTP.

Note

L’académie d’Amiens propose AmiensPython qui est un produit dérivé de Portable Python et qui contient entre autres une version francisée de Pyscripter.

Une fois cette installation faite, il suffit d’ouvrir Pyscripter et alors Python est prêt à l’emploi.

Annexes

Gestion des accents

En première ou deuxième ligne d’un script, il faut insérer la ligne :

# -*- coding: utf-8 -*-

ou bien

# -*- coding: latin-1 -*-

Il s’agit d’un pseudo-commentaire indiquant à Python le système de codage utilisé, ici l’utf8 (ou le latin-1) qui comprend les caractères spéciaux commme les caractères accentués, les apostrophes, les cédilles ...

Les égalités : attention

Il faut savoir que python n’est pas un logiciel de calcul formel, en tous cas pas sans l’importation d’un module adéquat. Donc a priori, il ne fait pas de calcul exact et il faut considérer que les valeurs numériques sont approchées. Il faut donc être prudent quand on teste si une égalité est vraie ou fausse.

>>> from math import sqrt
>>> a = sqrt(2)
>>> b = sqrt(3)
>>> c = sqrt(5)
>>> # testons maintenant une égalité
>>> a**2 + b**2 == c**2
False

Le résultat n’est pas celui attendu. En effet, on a bien

$(\sqrt{2})^2+(\sqrt{3})^2=(\sqrt{5})^2$

Différences entre Python2 et Python3

Pour connaitre toutes les différences entre Python2 et Python3, vous pouvez consulter cette section du site officiel. Mais voici celles qui sont les plus importantes pour le débutant.

`print`

C’est desormais une fonction. Pour l’utiliser il faut donc obligatoirement utiliser des parenthèses.

La division

Plus besoin du from __future__ import division qui était nécessaire pour que la division (/) soit bien décimale. Avec Python3, on a directement :

>>> 7/2
3.5

Avec Python2, on avait :

>>> 7 / 2
3
>>> from __future__ import division
>>> # la division est maintenant décimale
>>> 7 / 2
3.5

`imput`

Cette fonction renvoie automatiquement une chaine de caractères, même s’il est demandé de saisir un nombre.

`range`

Avant, avec Python2, on avait :

>>> range(5)
[0, 1, 2, 3, 4]

mainetnant, avec Python3, on a :

>>> range(5)
range(0, 5)

Et pour avoir le contenu de la liste générée, il faut utiliser la fonction list.

>>> list(range(5))
[0, 1, 2, 3, 4]

Messages d’erreur

Pour tout savoir, il faut se rendre à la documentation officielle. Pour faire simple, disons qu’il y a deux types d’erreur :

les erreurs de syntaxe comme par exemple l’oubli d’un : à la fin d’une ligne if,
les autres erreurs sont appelées exceptions.

Voyons les plus courantes pour le débutant.

>>> a = 0
>>> 1/a
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ZeroDivisionError: integer division or modulo by zero

Le message d’erreur ici est composé de trois lignes, mais c’est la dernière ligne qui doit être lue avec attention. Cette dernière rappelle que la division par zéro n’est pas autorisée. Le nom de l’exception ZeroDivisionError est d’ailleurs très clair.

Il faut aussi faire attention aux index des listes et se rappeler que la numérotation des listes commence à 0.

>>> maliste = [2, 5, 10]
>>> maliste[2]
10
>>> maliste[3]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range

L’exception IndexError indique ici que l’on est allé trop loin dans la numérotation.

Il faut aussi se rappeler que l’on ne peut pas faire d’opérations avec des variables qui n’ont pas été préalablement définies.

>>> b + 2
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'b' is not defined

L’exception NameError nous dit bien que la variable b n’a pas été définie.

Manipulation basique de listes et de texte

Manipulation de listes

>>> maliste = [0, "un", 2]  # on définit une liste pour faire des tests
>>> len(maliste)            # on demande sa longueur (length en anglais)
3
>>> maliste[0]              # on demande le premier élément (rang ou index 0)
0
>>> maliste[1]              # le deuxième (index 1)
'un'
>>> "un" in maliste         # on demande si le texte "un" est un élément de la liste
True
>>> "deux" in maliste
False
>>> maliste.index("un")     # on demande l'index (rang) de l'élément "un"
1
>>> maliste.count("un")     # on demande le nombre d'apparitions de l'élément "un"
1

Manipulation de texte

Note

Puisque Python considère qu’une chaîne est une liste de caractères, tout ce que nous venons de dire sur les listes est encore valable.

>>> montexte = "Blabla bli bloubloublou."
>>> len(montexte)
24
>>> montexte[0]
'B'
>>> montexte[1]
'l'
>>> montexte[23]
'.'
>>> "a" in montexte
True
>>> "z" in montexte
False
>>> montexte.index("B")
0
>>> montexte.index("b")
3
>>> montexte.index(".")
23
>>> montexte.count("b")
5

Certaines manipulations sont propres aux chaînes.

>>> montexte.lower()
'blabla bli bloubloublou.'
>>> montexte.strip(".")
'Blabla bli bloubloublou'
>>> montexte.split()
['Blabla', 'bli', 'bloubloublou.']
>>> montexte.lower().strip(".").split()
['blabla', 'bli', 'bloubloublou']

Ajouter du texte à du texte ou modifier par ajout

>>> montexte + " Merci."
'Blabla bli bloubloublou. Merci.'
>>> montexte
'Blabla bli bloubloublou.'
>>> montexte = montexte + " Merci."
>>> montexte
'Blabla bli bloubloublou. Merci.'
>>> montexte += " Beaucoup."
>>> montexte
'Blabla bli bloubloublou. Merci. Beaucoup.'

Manipulation avancée de listes et de texte

Prendre un élément en comptant à partir de la fin

>>> # On reprend une liste de test, un peu plus longue cette fois, et homogène.
>>> maliste = ["zéro", "un", "deux", "trois", "quatre", "cinq"]
>>> maliste[-1]     # on demande le dernier élément
'cinq'
>>> maliste[-2]     # l’avant-dernier
'quatre'
>>> maliste[-3]     # l’avant-avant-dernier (ou antépénultième), et ainsi de suite…
'trois'

Prendre une partie d’une liste

>>> maliste[1:3]    # Ici on demande une partie de la liste et non un élément seul.
['un', 'deux']
>>> # On remarque que cela fonctionne comme range(1,3), le 3 n’est pas compris.
>>> # Voyons maintenant si l’on ne précise pas l’indice de départ ou d’arrivée:
>>> maliste[1:]     # Sans indice d’arrivée, on ne s’arrête qu’à la fin,
['un', 'deux', 'trois', 'quatre', 'cinq']
>>> maliste[:3]     # sans indice de départ, on commence du tout début.
['zéro', 'un', 'deux']

Le mot le plus long

On présente ici un petit algorithme qui trouve le mot le plus long dans le texte stocké dans la variable texte.

>>> texte = "voici une suite de mots presque en vrac"
>>> mot_long = ""  # Cette variable contiendra le mot cherché.
>>> # Le recordman de longueur en quelque sorte.
... # Pour l’instant on stocke le mot vide "" dedans.
... mots = texte.split()              # On construit la liste des mots.
>>> for mot in mots:                  # On parcourt cette liste (boucle for).
...     if len(mot) > len(mot_long):  # Si le mot rencontré bat le record de longueur,
...         mot_long = mot            # on le proclame recordman.
...
>>> mot_long                          # On affiche le résultat.
'presque'

Liste des rangs d’apparition d’une lettre

>>> mot = "apparition"
>>> rangs = []                    # Cette liste va accumuler les rangs de la lettre *i*.
>>> for rang in range(len(mot)):  # La variable rang parcourt les entiers de 0 au rang de la dernière lettre du mot.
...     if mot[rang] == 'i':
...         rangs.append(rang)    # Si la lettre du mot est 'i', on stocke le rang dans notre liste.
...
>>> rangs                         # On affiche le résultat.
[5, 7]

Un peu plus sur les listes

On a déjà vu dans la section quelques bases quelques opérations importantes sur les listes.

D’autres points sur les listes sont abordés à la section manipulation avancée de listes.

Pour tout savoir, vous pouvez aussi vous reporter à http://docs.python.org/3/tutorial/datastructures.html .

Opérations admises

L’addition entre des listes et la multiplication d’une liste par un entier (naturel) sont autorisées. En voici quelques exemples d’utilisation :

>>> [1, 2, 3] + [7, 0]
[1, 2, 3, 7, 0]
>>> [1, 2, 3] * 4
[1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3]

Les méthodes

Sans rentrer dans les détails de la programmation orientée objet, les méthodes associées à un objet, ici une liste, s’utilise ainsi : objet.méthode(paramètres éventuels). On a déjà vu cette notation dans la section quelques bases avec la méthodeappend pour ajouter un élément à une liste et la méthode sort pour classer les éléments d’une liste (par ordre croissant s’il s’agit de nombres). Il y a d’autres méthodes qui s’appliquent aux listes :

extend pour ajouter les éléments d’une liste

>>> maliste = [1, 3, 2, 3]
>>> maliste.extend([8, 6])
>>> maliste
[1, 3, 2, 3, 8, 6]

insert pour insérer un élément à une place précise

>>> maliste = [1, 3, 2, 3]
>>> maliste[1] # rappel
3
>>> maliste.insert(1, 5)
>>> maliste
[1, 5, 3, 2, 3]

remove pour supprimer la première occurence d’un élément

>>> maliste = [1, 3, 2, 3]
>>> maliste.remove(3)
>>> maliste
[1, 2, 3]

pop pour retirer un élément en position donnée et le retourner

>>> maliste = [1, 3, 2, 3]
>>> maliste[0] # rappel
1
>>> elr = maliste.pop(0)
>>> maliste
[3, 2, 3]
>>> elr
1

index pour avoir la position de la première occurence d’un élément

>>> maliste = [1, 3, 2, 3]
>>> maliste.index(3)
1

count pour avoir le nombre d’occurences d’un élément

>>> maliste.count(3)
2

reverse pour inverser l’ordre dans la liste

>>> maliste = [1, 3, 2, 3]
>>> maliste.reverse()
>>> maliste
[3, 2, 3, 1]

Exemples

Tableau de valeurs

On peut facilement obtenir le tableau de valeur d’une fonction sur un intervalle borné avec un certain pas.

Considérons la fonction $g$ définie par $g(x)=\sqrt{x^4+1}$ . Si l’on souhaite obtenir les valeurs prises par la fonction sur l’intervalle $[2;3]$ avec un pas de $0,1$ , voici ce que l’on peut faire :

from math import sqrt

def g(x):
    return sqrt(x**4 + 1)

x = 2
while x < 3.1:
    print("g(",x,") =",g(x))
    x = x + 0.1

En exécutant ce script, voici ce que l’on obtient

g( 2 ) = 4.12310562562
g( 2.1 ) = 4.52195754071
g( 2.2 ) = 4.94222621902
g( 2.3 ) = 5.38368832679
g( 2.4 ) = 5.8461611336
g( 2.5 ) = 6.32949445059
g( 2.6 ) = 6.83356422374
g( 2.7 ) = 7.35826745912
g( 2.8 ) = 7.90351820394
g( 2.9 ) = 8.46924435826
g( 3.0 ) = 9.05538513814

On peut ne pas trouver très beau les espaces après et avant les parenthèses, puis vouloir que les arrondis à $10^{-2}$ près. Pour cela, il suffit d’utiliser les possibilités de formatage de la fonction print comme cela.

from math import sqrt

def g(x):
    return sqrt(x**4 + 1)

x = 2
while x < 3.1:
    print("g({:0.1f}) = {:0.2f}".format(x, g(x)))
    x = x + 0.1

Et on obtient :

g(2.0) = 4.12
g(2.1) = 4.52
g(2.2) = 4.94
g(2.3) = 5.38
g(2.4) = 5.85
g(2.5) = 6.33
g(2.6) = 6.83
g(2.7) = 7.36
g(2.8) = 7.90
g(2.9) = 8.47
g(3.0) = 9.06

Evidemment dans les deux cas, le signe = est affiché, mais il s’agit bien entendu d’une approximation. On peut signaler au passage l’existence de la fonction round() qui donne l’arrondi à la précision demandée

>>> round(12.456, 1)   # arrondi de 12.456 au dixième
12.5
>>> a = 8.743159
>>> round(a, 2)        # arrondi de a au centième
8.74
>>> round(a)          # arrondi à l'unité
9

Intervalle de fluctuation

On peut demander d’écrire un programme qui permet de déterminer l’intervalle de fluctuation au seuil de 95% à partir d’une liste de valeurs, connaissant évidemment le centre de l’intervalle. Voici une proposition avec une précision de l’ordre du millième.

# -*- coding:utf-8 -*-

# première entrée : la série en liste
serie = [0.674, 0.679, 0.681, 0.692, 0.705, 0.711, 0.718, 0.718, 0.732, 0.760]

# deuxième entrée : le centre de l'intervalle
centre = 0.7

# le nombre de valeurs
effectif_total = float(len(serie))   # float() inutile à partir de la version 3

# initialisation du rayon de l'intervalle
rayon = 0

# initialisation du taux de valeurs dans l'intervalle
taux = 0

# boucle où on augmente le rayon d'un intervalle centré sur la valeur centre
# jusqu'à atteindre le taux de 95%
while taux < 0.95:
    # initialisation de la variable qui compte
    # le nombre d'éléments dans l'intervalle
    effectif = 0
    for valeur in serie:
        if centre - rayon <= valeur <= centre + rayon:
            effectif += 1
    taux = effectif / effectif_total
    rayon += 0.001      # pour une précision au millième

print("[%0.3f , %0.3f]" %(centre - rayon, centre + rayon))

Un jeu de dé

On lance un dé. Si le numéro est 1, 5 ou 6, alors c’est gagné, sinon c’est perdu. Ecrire un programme simulant ce jeu d’abord sans utiliser de liste puis en utilisant une liste. Voici une première proposition :

# -*- coding:utf-8 -*-

from random import randint

d = randint(1, 6)
print(d)

if d == 1:
    print("gagné")
else:
    if d == 5:
        print("gagné")
    else:
        if d == 6:
            print("gagné")
        else:
            print("perdu")

En utilisant elif, on peut simplifier le script comme ceci :

# -*- coding:utf-8 -*-

from random import randint

d = randint(1, 6)
print(d)

if d == 1:
    print("gagné")
elif d == 5:
    print("gagné")
elif d == 6:
    print("gagné")
else:
    print("perdu")

Et maintenant en utilisant une liste, on peut faire encore plus simple :

# -*- coding:utf-8 -*-

from random import randint

d = randint(1, 6)
print(d)

if d in [1, 5, 6]:
    print("gagné")
else:
    print("perdu")