Instructions et structures de base pour la programmation Python : kit de survie

Cette page regroupe un ensemble d'éléments sur les instructions et structures de base proposés par Python. C'est une sorte de kit de survie pour vos premiers pas en Python : rassurez-vous, Python est pensé pour être simple, et en cas de problème, vous trouverez vite une solution (ici ou ailleurs) !

Commentaires

Les commentaires permettent de rendre le code plus compréhensible.

En Python, les commentaires sont précédés du caractère #.

Remarque : les documentations des modules, classes et fonctions sont réalisés à l'aide de commentaires spéciaux, les « doc strings », délimités par des double cotes (1 ou 3 : """) et accessibles à l'exécution contrairement aux commentaires standards.

def dire_bonjour():
    """
    Cette fonction dit bonjour.
    Je n'ai rien d'autre à dire, mais si c'était
    le cas, je pourrais bien l'écrire dans cette
    jolie doc string.
    """
    print "Bonjour" # Toute la magie opère sur cette ligne très complexe

Types de données prédéfinis

Les types de données de base les plus importants en Python sont :

Les nombres entiers (int et long), réels (float) et complexes (complex)
Les chaînes de caractères (str) et les chaînes de caractères unicode (unicode)
Les booléens (bool)

Pour connaître le type d'une variable, il existe une fonction pratique type() :

>>> chaine = 'pascal'
>>> type(chaine)
<type 'str'>

Il est possible de convertir de manière explicite (cast) une variable d'un type vers un autre type :

>>> a = '4'
>>> type(a)
<type 'str'>
>>> entier_a = int(a)
>>> entier_a
4
>>> type(entier_a)
<type 'int'>

Les listes, tuples, ensembles et dictionnaires

Les listes, tuples, ensembles et dictionnaires sont des structures de données qui peuvent être vus comme des conteneurs de plusieurs éléments. Ils ressemblent à des tableaux, dans lesquels on peut stocker n'importe quel type d'objet.

Listes

Une liste est représentée par une suite d'éléments délimitée par des crochets et séparés par des virgules. Une fois créée, on peut modifier une liste, en lui ajoutant, modifiant ou supprimant des éléments. Quelques exemples :

>>> maliste = [0, 1, 1, 2, 2, 3, 5, 8, 13] # Je crée une liste
>>> print maliste # Je l'affiche
[0, 1, 1, 2, 2, 3, 5, 8, 13]
>>> type(maliste) # Quel est le type de ma variable "maliste" ?
<type 'list'> # Ouf, c'est bien une liste !
>>> maliste[6] # J'accède au 7e élément de la liste (les index commencent à 0)
5
>>> maliste.pop(4) # Je retire le 5e élément de la liste
2
>>> maliste
[0, 1, 1, 2, 3, 5, 8, 13] # C'est le début de Fibonacci !
>>> maliste.append(21) # J'ajoute un élément à la fin
>>> print maliste
[0, 1, 1, 2, 3, 5, 8, 13, 21]
>>> autreliste = ['etc.'] # Je crée une autre liste, qui elle ne comporte qu'un élément
>>> maliste + autreliste # Je concatène mes deux listes avec l'opérateur +
[0, 1, 1, 2, 3, 5, 8, 13, 21, 'etc.']
>>> maliste[2:] # J'extrais les éléments de la position 3 jusqu'au bout
[1, 2, 3, 5, 8, 13, 21]
>>> maliste[:2] # J'extrais les deux premiers éléments
[0, 1]
>>> maliste[3:5] # J'extrais les éléments de la position 4 à 6 (les index commencent à 0)
[2, 3]
>>> len(maliste) # Quelle est la longueur de ma liste ?
9
>>> maliste[len(maliste)-3:] # J'extrais les 3 derniers éléments de la liste
[8, 13, 21]
>>> maliste[2] = 'coucou' # Je modifie un élément (celui qui est en 3e position !)
>>> print maliste
[0, 1, 'coucou', 2, 3, 5, 8, 13, 21]

Les listes Python viennent avec un outil extrêmement puissant : la compréhension de liste (list comprehension). Il s'agit d'utiliser une boucle for pour construire une liste, potentiellement avec une condition :

Code

print 'Carrés des nombres inférieurs à 4 :'
print [x ** 2 for x in range(4)]

Exécution

Carrés des nombres inférieurs à 4 :
[0, 1, 4, 9]

Un exemple de compréhension de liste, plus compliqué :

Code

etudiants = [
    {'nom': 'Dupont', 'promo': 'M1'},
    {'nom': 'Durand', 'promo': 'M2'},
    {'nom': 'Dupontel', 'promo': 'M1'},
    {'nom': 'Antoine', 'promo': 'M1'},
]

etudiants_m1 = [e for e in etudiants if e['promo'] == 'M1']
etudiants_m2 = [e for e in etudiants if e['promo'] == 'M2']

print "Inscrits en M1 :", etudiants_m1
print "Inscrits en M2 :", etudiants_m2

Exécution

Inscrits en M1 : [{'promo': 'M1', 'nom': 'Dupont'}, {'promo': 'M1', 'nom': 'Dupontel'}, {'promo': 'M1', 'nom': 'Antoine'}]
Inscrits en M2 : [{'promo': 'M2', 'nom': 'Durand'}]

Tuples

Les tuples ressemblent très fort aux listes, sauf qu'ils ne sont pas modifiables (on dit « immutable »).

Les tuples sont écrits entre parenthèses.

>>> montuple = (0, 1, 1, 2, 2, 3, 5, 8, 13)
>>> print montuple
(0, 1, 1, 2, 2, 3, 5, 8, 13)
>>> type(montuple)
<type 'tuple'>
>>> montuple[6]
5
>>> 9 in montuple
False
>>> 8 in montuple
True
>>> montuple.pop(4) # Non non, on ne peut pas !
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'tuple' object has no attribute 'pop'
>>> montuple[2] = 'coucou' # Non plus...
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

Ensembles (sets et frozensets)

Python propose une autre structure, les sets, qui permet de représenter des ensembles (collections non-ordonnées sans doublons) :

>>> liste_avec_doublons = ['pascal', 'pierre', 'paul', 'pierre']
>>> set(liste_avec_doublons)
set(['pascal', 'pierre', 'paul'])

Un autre type d'ensemble est disponible, le frozenset. Les propriétés des frozensets sont analogues à celles des sets, à la différence près que les frozensets sont immutables. On retrouve grosso-modo la même relation entre un frozenset et un set qu'entre un tuble et une liste :

un frozenset est un set immutable
un tuble est une liste immutable

Dictionnaires

Les dictionnaires Python sont l'équivalent de ce que l'on appelle parfois par ailleurs « tableaux associatifs ». Ils contiennent des éléments indexés par des clés. Les gens qui connaissent Javascript par exemple, devraient se trouver familiers avec ces constructions.

Voici quelques exemples :

>>> berti = {'nom': 'Bertignac', 'prenom': 'Louis', 'instruments': ['guitare', 'chant']}
>>> print berti
{'nom': 'Bertignac', 'prenom': 'Louis', 'instruments': ['guitare', 'chant']}
>>> berti['nom']
'Bertignac'
>>> berti['instruments']
['guitare', 'chant']
>>> berti['groupes'] = ['Higelin', 'Telephone', 'Bertignac et les visiteurs']
>>> berti
{'nom': 'Bertignac', 'prenom': 'Louis', 'groupes': ['Higelin', 'Telephone', 'Bertignac et les visiteurs'], 'instruments': ['guitare', 'chant']}
>>> del berti['instruments']
>>> berti
{'nom': 'Bertignac', 'prenom': 'Louis', 'groupes': ['Higelin', 'Telephone', 'Bertignac et les visiteurs']}

De manière analogue à ce que nous avons vu sur les listes avec la compréhension de liste, il est possible de construire des dictionnaires en compréhension : outil très puissant ! Voici un exemple :

Code

personnes = ['PAUL', 'Pierre', 'jean']
print {p.lower(): len(p) for p in personnes}

Exécution

{'jean': 4, 'paul': 4, 'pierre': 6}

Structures conditionnelles

Comme tout langage de programmation, Python fournit les structures conditionnelles nécessaires à toutes les applications (if/else/elif) :

Syntaxe

if expression:
    instructions
elif expression_2:
    instructions
else:
    instructions

Exemple simple

if age_du_capitaine < 16:
    print "Le capitaine doit aller à l'école"
elif age_du_capitaine >= 60:
    print "Le capitaine peut partir en retraite"
else:
    print "Le capitaine est actif (ou étudiant...)"

Voici une illustration de l'utilisation d'une structure conditionnelle sur un exemple un peu plus compliqué :

# -*- coding: UTF-8 -*-
import re

nom = raw_input('Quel est votre prénom ')

if len(re.split('[ -]', nom)) > 1:
    print "Vous avez un prénom composé !"
else:
    print "Votre prénom ne contient qu'un mot."

…donnera à l'exécution :

$ python hello_world.py
Quel est votre prénom ? Pascal
Votre prénom ne contient qu'un mot.
$ python hello_world.py
Quel est votre prénom ? Jean-Pascal
Vous avez un prénom composé !
$ python hello_world.py
Quel est votre prénom ? Pierre Antoine
Vous avez un prénom composé !

Structures itératives

Les structures itératives sont plus généralement connues sous le nom de « boucles ». On retrouve notamment en Python les classiques boucles while et for.

Boucle while

Assez classique…

Code

compteur = 1
while compteur < 5:
    print "Et de {nombre}".format(nombre=compteur)
    compteur = compteur +1

Exécution

Et de 1
Et de 2
Et de 3
Et de 4

Boucle for

La boucle for de Python peut parfois être déroutante pour les débutants. En effet, elle ne fonctionne pas comme un compteur, comme c'est le cas dans beaucoup de langages, mais comme une implémentation du design pattern itérateur. Donc, grosso modo, comme un « foreach » :

Code

for personne in ['Jean', 'Paul', 'Simon']:
    print personne

Exécution

Jean
Paul
Simon

On peut faire en sorte que la boucle for de Python fonctionne comme une boucle for traditionnelle. Pour cela, on utilise généralement la fonction intégrée range() :

Code

for index in range(10):
    print index

Exécution

Il est également possible, en itérant sur une liste, de récupérer l'élément et son index, grâce à la fonction enumerate() :

Code

for index, nom in enumerate(['Jean', 'Paul', 'Simon']):
    print index, nom

Exécution

0 Jean
1 Paul
2 Simon

Enfin, quand on travaille sur un dictionnaire, il est possible d'itérer sur les éléments du dictionnaires (paires clé/valeur), grâce à la fonction items() :

Code

berti = {'nom': 'Bertignac', 'prenom': 'Louis', 'instruments': ['guitare', 'chant']}

for cle, valeur in berti.items():
    print cle, valeur

Exécution

nom Bertignac
prenom Louis
instruments ['guitare', 'chant']

Fonctions

La déclaration d'une fonction Python peut se faire à peu près partout dans le code d'un programme : au début, à l'intérieur d'une autre fonction, dans une classe (on parle alors de méthode bien que la syntaxe soit identique)… On utilise pour cela le mot clé def :

Code

def dire_bonjour(nom):
    return 'Bonjour {qui}'.format(qui=nom)

print dire_bonjour('Pascal')

Exécution

Bonjour Pascal

Opérateurs

Les opérateurs arithmétiques fonctionnent de manière analogue à ce que l'on peut voir dans la plupart des langages.

En particulier :

L'addition (+)
La soustraction (-)
La multiplication (*)
La division (/)
Le modulo (%)
La puissance (**)

Idem pour la comparaison :

Égalité (==)
Non égalité (!=)
Inférieur, inférieur ou égal (<, <=)
Supérieur, supérieur ou égal (>, >=)

Enfin, Python fournit des opérateurs de conjonction d'expressions :

and
or
not

Bien entendu, les opérateurs peuvent être utilisés conjointement :

Code

print 1 < 2 or 1 > 2

Exécution

True

Variables et affectation

Comme dans beaucoup de langages, les variables en Python sont nommées (en commençant par une lettre ou un underscore), et de manière sensible à la casse. Exemple : ma_variable = 5.

Lectures conseillées

L'intéressante intervention d'Alex Gaynor à PyCon 2011 : The Data Structures of Python (et son fameux crash d'ordinateur en pleine présentation :)

Testez vos connaissances

Que fait cette instruction : 1+2*5 ?

Elle calcule 2*5 puis y ajoute 1.
Elle calcule 1+2 puis multiplie le résultat par 5.
Elle fait le café.
Elle réalise des opérations arithmétiques.