IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)

Initiation à Python


précédentsommairesuivant

III. Notions essentielles

III-A. Premier programme

Lancer l'interpréteur Python. En ligne de commande, cela est très facile. Ouvrez un terminal et écrivez python. Ensuite, à l'invite Python commençant par >>>, écrivez

 
Sélectionnez
1+1

Programmer c'est comme utiliser une calculatrice, pas plus compliqué. Ce qui est compliqué, c'est ce qu'on veut faire et savoir comment le faire. Le reste, c'est Python qui le fera. Mais pour cela, vous devrez bien définir que vous souhaitez obtenir.

soustraction : -

multiplication : *

division : /

division résultat entier : /

modulo : %

parenthèses : ()

III-B. Conserver le programme

Lancer un éditeur de texte ou encore un éditeur Python. Écrivez alors les lignes suivantes :

 
Sélectionnez
#!/usr/bin/python
1+1

Enregistrez le fichier sous le nom ex1.py.
Exécuter en ligne de commande dans un terminal avec : python ex1.py.

L'enregistrement des programmes Python dans un fichier n'est pas nécessaire mais c'est cependant le seul moyen fiable de préserver les lignes écrites pour pouvoir les réutiliser. En effet, si dans le cadre de ce cours il suffira bien souvent d'utiliser l'historique de l'interpréteur Python, dans le cadre de projet plus complets, il sera plus pratique de tout enregistrer. Cela facilitera en particulier le débogage.

À l'heure actuelle, pour ceux qui utilisent des systèmes récents et Python 3, il est conseillé d'écrire dans un logiciel compatible utf-8 ce qui permet de ne pas voir de messages d'erreur apparaître dès qu'un accent est trouvé dans le fichier. Dans ce cas, c'est une bonne idée d'en informer Python en rajoutant une ligne spécifique en début de fichier :

 
Sélectionnez
-*- coding: utf-8 -*-

ce qui donne au complet :

 
Sélectionnez
#!/usr/bin/python
1+1

Évidemment, ces quelques lignes ne sont pas très sexy et ne réalisent pas grand-chose d'extraordinaire, mais en programmation, tout projet commence avec des choses simples. Le vrai problème de ce programme et de ne laisser aucune variation dans les données : il ne peut servir qu'à faire ce calcul particulier soit 1+1, ce qui est un peu limitatif. Un programme devrait pouvoir s'adapter à différentes situations.

III-C. Découvrir les variables

La variable est un élément d'un programme dont la valeur pourra changer en fonction des besoins. Il s'agit d'une sorte de boîte de stockage (tiroir) dont le contenu pourra varier.

Ainsi au lieu d'écrire :

 
Sélectionnez
1+1=2

on peut écrire :

 
Sélectionnez
a+a=b

le calcul sera toujours valable même si on remplace 1 par 2. Seul le résultat sera adapté.

 
Sélectionnez
2+2=?

La variable sera donc bien souvent une simple lettre ou un mot qui identifie les éléments à traiter ou à calculer. Cela va rappeler quelques heures douloureuses des maths au collège, mais tout va bien se passer.

Il faudra assigner (affecter) la valeur à la variable a avant que le calcul soit possible en Python. Il s'agit simplement d'informer des chiffres qui doivent être pris en compte dans le calcul et intervenir en remplacement des variables (ici les lettres).

L'affectation se fait à l'aide de l'opérateur =

 
Sélectionnez
a=2
b=a+a
b

Affiche : 4

Le nom des variables doit être le plus parlant possible. Dans notre cas, a ou b ont l'avantage d'être courts, mais n'expriment pas grand-chose. On pourrait utiliser des noms de variables comme age, largeur, hauteur…

Le nom des variables est libre. Cependant, il ne peut contenir que des lettres, chiffres et underscore. Enfin il ne peut commencer par un chiffre et ne doit pas être identique à un mot réservé du langage Python. Cette contrainte est importante pour éviter toute confusion.

Dernier point important qui exigera un peu de rigueur : Python est sensible à la casse. Essayez :

 
Sélectionnez
a=2
b=A+100

NameError: name 'A' is not defined

est le message renvoyé par l'interpréteur pour vous spécifier qu'il n'a pas compris votre instruction. Ici il vous précise qu'il ne connaît aucune variable nommée 'A'.

Comme on peut le voir dans les exemples précédents, l'affection peut être simple ou composée. Elle peut soit attribuer une valeur fixe a=2, soit attribuer un calcul b=a+a. Dans ce dernier cas, b sera toujours le résultat de ce calcul quel que soit la valeur donnée à a. Cependant, cette valeur est calculée au moment où l'affectation est effectuée.

 
Sélectionnez
a=2
b=a+a
b

Affiche : 4

Mais si l'on continue :

 
Sélectionnez
a=3
b

affiche : 4

Il faudra alors spécifier à nouveau l'affectation et le calcul :

 
Sélectionnez
a=3
b=a+a
b

affiche : 6

Ainsi, une affectation est valable tant qu'elle n'a pas été remplacée par une nouvelle et le résultat d'une opération tant que celle-ci n'a pas été reconduite.

III-D. Les types simples : str, int, float

Les variables sont typées. Cela signifie qu'elles acceptent un certain type de contenu, pas d'autre, un peu comme une voiture qui ne fonctionne pas avec tous les types de carburant.

Les deux types principaux et les plus simples sont les types permettant l'interprétation des nombres entiers (pour faire des calculs si besoin) et du texte (pour évaluer par exemple ce qu'un utilisateur a saisi comme mot de passe ou autre).

Le typage, c'est-à-dire l'attribution d'un type, se fait principalement au moment de la déclaration :

 
Sélectionnez
a=2

signifie implicitement que la valeur de a est de type entier car 2 est bien un nombre entier.

 
Sélectionnez
nom="cedric"

Signifie implicitement que la valeur de cedric est de type texte (nous dirons « chaîne », comme une suite de lettres).

Il existe de nombreux types, mais entier et chaîne sont les plus simples et fréquents. Nous pouvons y ajouter dès maintenant le type float qui est prévu pour les nombres décimaux. Nous obtenons donc l'association suivante :

  • a=2  integer   nombre entier ;
  • a="texte"  string   chaîne de caractères ;
  • a=2.0  float   nombre décimal.


Là où il va être important de donner une bonne attention aux types tient au fait qu'il est impossible de combiner des données de types différents dans un calcul :

 
Sélectionnez
a=2
nom="cedric"
b=nom+a

TypeError:cannot concatenate 'str' and 'int' objects

Python nous informe qu'on ne peut ajouter des chiffres et des lettres. Jusque-là tout est normal, même si dans certains cas, comme nous le verrons, cela devra être contourné. Vous devez vous dire « Mais qu'est-ce qu'il est bête ! ». C'est un peu vrai, mais vous conviendrez que les cas de devoir effectuer des calculs sur des mots sont assez rares ! Et puis regardez maintenant :

 
Sélectionnez
a=2
b=1.5
c=a+b
c

affiche : 3.5

Il est donc possible de faire des calculs entre des entiers et des flottants, bref des chiffres, tout est donc normal. Remarquez simplement la façon d'écrire les chiffres qui n'utilise pas une virgule mais un point (à l'anglaise).

III-E. Afficher des valeurs et résultats

Dans le cadre de l'écriture de nos programmes, nous avons souvent besoin d'afficher des résultats. Vous avez certainement remarqué que Python ne fait pas cela immédiatement :

 
Sélectionnez
a=2
b=3
c=a+b

il n'affiche pas le résultat de calcul pour c. Il faut donc lui dire. Jusqu'à présent, nous avons simplement provoqué cet affichage en écrivant simplement le nom de la variable :

 
Sélectionnez
c

affiche : 5

Mais comment faire si nous souhaitons afficher plusieurs informations. Par exemple :

 
Sélectionnez
a b c

affiche : SyntaxError: invalid SyntaxError

Il ne comprend pas ce que nous souhaitons faire et nous informe que la syntaxe de notre ligne est mal faite. Mettre à la suite les noms de variables n'est pas assez clair : doit-il les calculer ? Dans ce cas comment ? Les afficher ?

Il existe de nombreuses façons d'afficher du contenu, mais pour l'instant, l'utilisation de la fonction print sera amplement suffisant :

 
Sélectionnez
age=100
print age


affiche : 100

 
Sélectionnez
print "j'ai ", age," ans."


affiche : j'ai 100 ans


Remarquez ici que les mots qui doivent apparaître tels quels sont écrits entre guillemets et que les variables n'en ont pas besoin. Les virgules entre chaque partie de la phrase sont absolument nécessaires pour éviter toute erreur. Elles servent à Python pour comprendre que le texte se poursuit, finalement comme des parties d'une phrase. Il s'agit d'une concaténation : ajout d'informations à la suite les unes des autres.

III-F. Interagir avec l'utilisateur

Lorsque nous souhaitons réutiliser nos portions de codes, nous les enregistrons dans des fichiers de manière à ce qu'ils constituent de véritables petits programmes. Le problème que nous rencontrons dans ce cas est de pouvoir transmettre des informations au programme sans avoir modifié le code systématiquement. En particulier, si nous souhaitons calculer le périmètre d'une zone, le calcul étant systématiquement identique, il nous faudra cependant modifier les variables.
Pour :

perimetre=(largeur+hauteur)*2

notre programme serait :

 
Sélectionnez
largeur = 100
hauteur = 200
perimetre=(largeur+hauteur)*2
print perimetre

Pour éviter d'éditer notre fichier, ce qui est long et risque d'y introduire des erreurs par mégarde, nous pouvons mentionner à notre programme de demander à l'utilisateur de saisir les informations quand elles sont nécessaires :

 
Sélectionnez
largeur = input()
hauteur = input()
perimetre = (largeur + hauteur) * 2
print perimetre

Enregistrez votre programme sous le nom perimetre.py et exécutez-le dans une console/terminal :

python perimetre.py

Dans le cas où la valeur a récupérer est une chaîne de caractères, Python renverra une erreur. Mieux vaut utiliser raw_input.

 
Sélectionnez
nom_de_forme = raw_input()

De nombreuses personnes conseillent d'utiliser raw_input dans tous les cas de figure, mais il faudra alors transtyper la variable.

III-G. Connaître et modifier un type

Pour connaître le type d'une variable, il existe deux façons principales qui donnent des résultats sensiblement différents.

III-G-1. type()

Pour connaître le type d'une variable, il suffit d'utiliser une fonction interne à Python qui s'écrit invariablement sous la forme :

 
Sélectionnez
type(nom_de_variable)

par exemple :

 
Sélectionnez
a=100
type(a)

qui renvoie : <type 'int'>

Cela est en particulier utile pour connaître le type qui résulte d'une opération :

 
Sélectionnez
a=100
b=0.5
c=a*b
type(c)

qui renvoie le résultat : <type 'float'>

Python a attribué tout seul le type.

Pour modifier le type de la variable, il faudra utiliser des fonctions spécifiques à chaque type de destination :

int() pour convertir en entier.

str() pour convertir en chaîne de caractères.

Pour informer Python de la variable à typer à nouveau, il suffit de donner son nom entre les parenthèses.

 
Sélectionnez
#reprendre programme avec raw_input >
largeur = int(raw_input())
hauteur = int(raw_input())
perimetre = (largeur + hauteur) * 2
print perimetre

exo : améliorer ce script pour qu'il soit plus lisible en rajoutant des phrases d'explications à l'utilisateur.

III-H. Comparer des données

Nous avons déjà effectué des petits programmes. Mais ils ne suffiront certainement pas à la plupart des situations. C'est une étape importante que de programmer en prenant en compte de critères que nous, développeurs, n'aurions pas besoin nécessairement d'utiliser à un moment donné. La variable était déjà une façon de prendre en compte la diversité des valeurs possibles pour une information. Maintenant, il existera des cas dans lesquels le calcul ne peut être effectué ou ne doit pas l'être. Pour détecter ces cas, il suffira de comparer les données fournies avec des valeurs spécifiées pour s'assurer que certaines conditions sont remplies. Par exemple, gardons notre programme calculant le périmètre, mais incluons de quoi calculer les dimensions en fonction d'une unité fournie. Pour cela, nous demanderons à l'utilisateur de choisir entre deux possibilités, nous testerons ce qu'il a saisi et afficheront le résultat dans l'unité de son choix.

La comparaison la plus simple se fait à l'aide de if…else… s'écrivant sous une forme bien particulière :

 
Sélectionnez
if comparaison :
    action à effectuer si la comparaison est valable
else :
    action à effectuer si elle ne l'est pas

Dans cette structure de base, sont absolument nécessaires :
les : à la fin de la ligne if et else
la tabulation en début des lignes d'actions, nommées en général « bloc d'instruction ».

le concept d'indentation (tabulation en début de ligne) est un concept fondamental en Python.

Les retraits permettent à Python de comprendre la suite et l'imbrication des actions et d'éviter au programme de se tromper de direction.

Revenons maintenant à notre exemple.

Pour demander les possibilités, nous utiliserons pour l'instant une simple solution : nous écrirons les unités possibles et attendrons que l'utilisateur saisisse la valeur. Nous utiliserons donc print et raw_input().

 
Sélectionnez
print "votre unité de mesure finale voulue : mètre ou centimètre ?"
unite = raw_input()

Il suffit alors de reprendre le programme tel que nous l'avions défini et de nous placer à la dernière ligne.

 
Sélectionnez
if unite == "mètre" :
    print perimetre, " mètre" #nous considérons qu'il les a écrit en mètre
else :
    print perimetre*100, " cm"

Si le nombre de conditions est supérieur à 2 la structure if…else… ne sera pas suffisante. Dans ce cas, nous pourrons avoir recours à sa variante : if…elif…elif…else…

Elle s'écrira plus précisément sous la forme :

 
Sélectionnez
if unite == "mètre" :
    print perimetre, " mètre"
elif unite == "centimètre" :
    print perimetre*100, " centimètre"
elif unite == "millimètre" :
    print perimetre*1000, " millimètre"
elif unite == "kilomètre" :
    print perimetre/1000, " kilomètre"

Une version plus courte d'écrire les tests simples est souvent utilisée. Il s'agit de l'opérateur dit ternaire.

Alors qu'une condition occupe quatre lignes avec la syntaxe de base, avec l'opérateur ternaire, tout sera sur une seule ligne. Cela peut être pratique quand les lignes se multiplient et les niveaux d'indentation aussi. La syntaxe est la suivante :

 
Sélectionnez
x = true_value if condition else false_value

La forme de cette expression peut sembler un peu étrange du fait qu'elle est inversée et fonctionne directement en mode affectation. Au lieu d'exprimer : « si une condition est vraie ou fait ceci, sinon on fait cela », on exprime : « on fait cela si une condition est vraie sinon va voir ailleurs ». Il s'agit d'une petite chose mais qui marche parfaitement pour les petits besoins. Évidemment, le rôle de l'opérateur ternaire n'est pas de prendre la place de blocs d'instructions complexes.

III-I. Comparaisons de grandeur

Dans la partie Comparer des données, nous avons testé si la valeur saisie par l'utilisateur correspondait exactement à celle que nous cherchions. Mais comment cela se passe-t-il si nous cherchons un ordre de grandeur, par exemple, savoir si un chiffre est plus grand qu'un autre ?

Pour cela, nous utiliserons des opérateurs de comparaison. Ces opérateurs, vous les connaissez déjà certainement et les utilisez presque tous les jours. Commençons par celui que nous avons déjà vu et passons aux plus courants :

  • ==   égal à ;
  • <   plus petit (inférieur) et strictement plus petit ;
  • <=   plus petit (inférieur) ou égal ;
  • >   plus grand (supérieur) et strictement plus grand ;
  • =>   égal ou plus grand (supérieur).

Il en existe un autre moins évident et pourtant pratique :

  • !=   différent de, qui sert justement de contraire à la simple comparaison d'égalité.

Les cas d'utilisation de ces opérateurs sont nombreux. Demander son âge à un utilisateur d'un site Web pour lui donner accès. Valider un code postal ou un numéro de téléphone. Donner accès à des messages ou un contenu dans une langue particulière… Bref, les applications ne manquent pas.

Complétons notre exemple pour qu'il prenne en compte ces critères : afficher les chiffres en kilomètres dès qu'ils sont supérieurs à 1000, les messages sont en anglais si la personne n'est pas française. Les modifications seront alors assez importantes. Le chiffre renvoyé ne sera pas le fruit de la saisie d'unité de l'utilisateur. Cette question ne sera donc plus nécessaire. En revanche, nous devrons demander la langue. Voilà ce que cela pourrait donner :

 
Sélectionnez
print "Quelle est votre langue ? "
langue = raw_input()
if langue != "fr" :
    message = "hello, the length is "
else :
    message = "Bonjour, la longueur est "
unite = "mètre"
if perimetre > 1000 :
    if langue != "fr":br>
        unite = "kilometer"
    else :
        unite = "kilomètre"
    print message, perimetre/1000, unite
else
    print message, perimetre, unite

III-J. Associer des comparaisons

Il est parfois nécessaire d'effectuer plusieurs comparaisons successives sur un même élément voire entre plusieurs éléments. La forme d'écriture la plus simple va demander d'écrire de nombreuses lignes sans pour autant augmenter la lisibilité :

 
Sélectionnez
n = input()
  
if n < 10 :
  
    if n > 3 :
        print "n est compris entre 3 et 10"

De la même façon, la ligne qui suit teste si le chiffre est bien dans la plage souhaitée :

 
Sélectionnez
n = input()
  
if n < 10 and n > 3 :
    print "n est compris entre 3 et 10"

L'opérateur and permet ainsi d'associer les deux comparaisons en une seule. Dans ce cas, la condition est remplie si le chiffre est compris dans les deux expressions cumulées.

Nous pourrions souhaiter que seulement l'une des expressions soit validée. Dans ce cas, le recours à or sera plus judicieux :

 
Sélectionnez
if n < 10 or n > 20 :
    print "ok"

sera valable si le chiffre saisi est inférieur à 10 mais aussi s'il est supérieur à 20.

Enfin, l'opérateur not peut être utilisé pour exclure une possibilité :

 
Sélectionnez
if n not 10 :
    print "ok"

Dans ce cas, il agira un peu comme !=. L'avantage de ces opérateurs est cependant aussi de pouvoir s'appliquer à un type spécial, dit booléen et qui n'accepte que deux possibilités : True ou False

Ce type d'opérateur est utile pour mémoriser la réussite d'un test, sans pour autant que sa valeur soit préservée (par exemple, lorsque vous êtes connecté à un compte Web, on se souvient que vous êtes validé quand vous changez de page, mais il n'est pas nécessaire de renvoyer vos données), ou encore lorsque Python renvoie ce type comme résultat. Ainsi, on peut remplacer :

 
Sélectionnez
if n < 10 or n > 20 :
    print "ok"

par

 
Sélectionnez
if n < 10 or n > 20 :
    n_ok = True

et réutiliser ensuite ce résultat :

 
Sélectionnez
if n_ok == True :
    print "ok"

>> ok

ou

 
Sélectionnez
if n_ok is True :
   print "ok"

>> ok


précédentsommairesuivant

Licence Creative Commons
Le contenu de cet article est rédigé par Floss Manuals et est mis à disposition selon les termes de la Licence Creative Commons Attribution 3.0 non transposé.
Les logos Developpez.com, en-tête, pied de page, css, et look & feel de l'article sont Copyright © 2013 Developpez.com.