Instructions et blocs d'instructions

Dans le langage Python, chaque instruction occupe une ligne : il n'y a pas de symbole de fin, nous passons simplement à la ligne après chaque instruction.

Les blocs d'instructions, eux, ne sont pas délimités par un symbole particulier mais répérés par l'indentation des instructions :

• des instructions qui sont dans le même bloc ont le même nombre d'espaces à leur gauche,
• pour marquer le début d'un nouveau bloc, on va rajouter quelques espaces par rapport à l'instruction précédente.

Idéalement, nous aimerions utiliser la touche tabulation du clavier et que notre éditeur amène le curseur à l'endroit adéquat en produisant le nombre d'espaces nécessaires. Conclusion : choisissez et réglez bien votre éditeur !

Types et variables

Python autorise, sans déclaration aucune, la manipulation de types classiques : booléens, entiers, réels, caractères, chaîne de caractères.

pi = 3.14   # déclaration et affectation d'un nombre
z  = 'toto' # affectation d'une chaîne de caractères

Notons la syntaxe permettant d'écrire des commentaires dans le code Python : le signe # indique que la suite de la ligne n'est pas destinée à Python mais à un lecteur humain.

Comme suggéré ci-dessus, le symbole = est réservé à l'affectation d'une valeur à une variable. Le symbole ==, lui, permet d'exprimer un test d'égalité qui ne modifie en rien les variables.

Lorsque nous souhaiterons des conversions explicites d'un type à l'autre, nous utiliserons str pour obtenir une chaîne de caractères (à partir d'un nombre) et int pour obtenir un entier (à partir d'un texte par exemple).

n = '6'                   # une chaîne de caractères
r = int(n) * 7            # ... convertie en entier pour calcul
print('réponse: '+str(r)) # ... et retour en chaîne pour affichage

Opérateurs

Nous disposons en Python des opérateurs arithmétiques classiques : +, -, *, /, // pour la division entière et % pour l'opération modulo (reste de la division).

Sur les chaînes de caractères, nous trouvons l'opérateur de concaténation noté par un plus (symbole +, comme pour l'addition entre entiers) et un opérateur de répétition des chaînes avec un fois (symbole *, comme pour la multiplication entre entiers),

i     = 10
i     = i + 8
texte = 'La variable i vaut '+str(i)
texte = texte+"\n"
print(texte)
print('coucou'*3) # répéter une chaîne

Nous retrouvons également les habituels opérateurs logiques : and, or et not.

Instruction de sortie et chaînes de caractères

Les affichages sont en Python réalisés à l'aide de l'instruction print(text,end="final") : elle affiche le text et termine cet affichage avec final. Si la partie end="final" n'est pas précisée Python utilise end="\n", ce qui signifie que l'on passe à la ligne après l'affichage de text.

Enfin, notons que nous pourrons confier en une fois plusieurs éléments à afficher à l'instruction print. Voici quelques exemples qui illustrent différentes utilisations possibles de print.

print("coucou hé !")  # affiche et passe à la ligne
print("toto","titi")  # titi suit toto, passage à la ligne
print("toto",end="+") # termine par un + et pas par un passage à la ligne
print("titi")         # titi s'ajoute à toto et passage à la ligne
print()               # simple passage à la ligne

Chaînes de caractères

Le langage Python permet de délimiter les chaînes de caractères soit par des apostrophes, soit par des guillemets. Il est pratique d'utiliser les guillemets lorsque le texte contient une apostrophe, et vice-versa. Il est aussi possible d'utiliser un backslash (signe \) pour neutraliser la signification Python d'un caractère.

prenom = 'Toto'
print("salut",prenom)
print("ça va aujourd'hui ?")
print('oui, ça va aujourd\'hui !')

Python autorise les chaînes de caractères de sur plusieurs lignes...

extractions et substitutions avec les slices.

Les chaînes de caractères en Python, ne sont pas modifiables... Toute modification implique donc la création d'une nouvelle chaîne de caractères.

formatage

Fonctions et procédures en Python

Rappelons que procédures et fonctions ont en commun d'utiliser des paramètres et de rassembler des instructions quelconques. Par contre, une fonction doit toujours se terminer par le renvoi d'un résultat (à l'aide du mot-clef return en Python), ce qui n'est jamais le cas pour une procédure. Cela signifie en particulier qu'un appel à une fonction se trouvera souvent dans la partie droite d'une affectation, par contre un appel à une procédure ne pourra pas être à cette position.

Définition et utilisation d'une procédure

# forme générale d'une procédure
def nom_de_la_procédure (paramètres):
    # ...
    # des instructions ici
    # ...

# procédure qui affiche entre étoiles un texte donné
def affiche_joliment (msg):
    print('***',msg,'***')

# on appelle la procédure et on renseigne son paramètre
affiche_joliment('coucou')

Définition et utilisation d'une fonction

# forme générale d'une fonction
def nom_de_la_fonction (paramètres):
    # ...
    # des instructions ici
    # ...
    return(résultat)

# fonction qui calcule la somme de deux entiers et la renvoie
def addition (x,y):
    s = x+y
    return(s)


# on appelle la fonction et on renseigne ses paramètres
somme = addition(2,2)
print('le résultat est',somme)

Structures de contrôle en Python

Modulo les notations propres à Python, nous retrouvons les structures de contrôle classiques, en particulier celles vues en cours d'algorithmique.

Structure conditionnelle : le si alors sinon

# forme générale
if (une condition ici):
    # ...
    # des instructions ici
    # ...
else:
    # ...
    # des instructions ici
    # ...

# affichage si un test est vrai
temperature = 28
if temperature>25:
    print('il fait chaud !')

# affichages distincts selon un test
temperature = 28
if temperature>25:
    print('il fait chaud !')
else:
    print('il fait frais...')

# enchaînement de tests
temperature = 28
if temperature>25:
    print('il fait chaud !')
elif temperature>20:
    print('il fait bon.')
else:
    print('il fait frais...')

Structure itérative : la boucle tant que

# forme générale
while (une condition ici):
    # ...
    # des instructions ici
    # ...

# on compte de 1 à 10
i = 1
while (i<=10):
    print(i)
    i = i + 1

Structure itérative : la boucle pour

La fonction range permet de définir un intervalle, intervalle qui peut être parcouru à l'aide de la boucle for ... in ....

# forme générale
for i in range(min,max):
    # ...
    # des instructions ici
    # ...

# affichage de 10 étoiles
for i in range(1,11):
    print('*')

# on compte de 1 à 10
for i in range(1,11):
    print(i)

Nous verrons plus loin une utilisation plus générale de cette boucle pour parcourir les éléments d'une séquence quelconque.

Les listes Python

Pas de contrainte sur le contenu des cases, celles-ci sont numérotées à partir de 0. Tout d'abord, nous voyons les différentes manières de créer une liste et de lui affecter des valeurs.

# création d'une liste vide et définition de trois cases
l = []
l.append(2)
l.append(3.14)
l.append('coucou')

# liste fournie par range (entiers de 1 à 100)
premiers = range(1,101)

# une liste de notes
notes = [5,12,8,20,10] # on définit une liste
notes[2] = 9           # on modifie la 2ème case

Ensuite, Python propose plusieurs syntaxes pour parcourir une liste. Notons l'expression len(l) qui fournit la taille d'une liste l et la boucle for in dédiée au parcours de listes.

# affichage des éléments de la liste...

# ... en utilisant les indices et la longueur de la liste
for i in range(0,len(notes)) :
    print(notes[i])

# ... et plus simplement :
for note in notes:
    print(note)

# ... et pourquoi pas :
print(notes)

Méthodes Python dédiées aux listes :

• list permet de copier une liste existante pour en créer une nouvelle,
• remove efface la première occurrence d'un élément dans une liste,
• del supprime une case,
• insert ajoute un élément à une position donnée d'une liste,
• append ajoute un élément en fin de liste,
• pop supprime et fournit le dernier élément d'une liste.

notes = [5,12,9,20,12,10] # définition d'une liste
l = list(notes)           # copier la liste
l.append(12)              # ajout de 12 en fin de liste
l.insert(3,14)            # ajout de 14 en position 3
del(l[2])                 # suppression de la case 2
l.remove(12)              # suppression du premier 12
l.pop()                   # suppression du dernier élément
print notes               # donne [5, 12, 9, 20, 12, 10]
print l                   # donne [5, 14, 20, 12, 10]

Retour sur les chaînes de caractères : il est parfois commode de voir les chaînes de caractères comme des listes de caractères, et effectivement Python permet d'appliquer aux chaînes les opérations dédiées aux listes.

# définition d'une chaîne de caractères
phrase = "coucou"

# parcours d'une chaîne caractère par caractère
for l in phrase
    print(l)
print()

# autre parcours caractère par caractère
for i in range(0,len(phrase)):
	print(phrase[i],end="-")
print()

Les dictionnaires Python

Les dictionnaires sont des listes dont la particularité est que les cases ne sont plus indicées par des numéros mais par des objets plus complexes, comme des textes. Ces textes qui servent d'indices sont appelés les clefs du dictionnaire.

Premiers exemples avec la définition d'un carnet d'adresses mails, les clefs du dictionnaire sont les noms des personnes :

# définition d'un dictionnaire vide
mails = {}

# définition du mail de Titi
mails['Titi'] = 'titi@univ.fr'

# définition du mail de Toto
mails['Toto']  = 'toto.machin@free.fr'

# affichage du mail de Toto
print('Mail de toto :',mails['Toto']);

Autre exemple, l'implémentation d'un type abstrait « produit », ici un type « livre » :

# définition d'un premier livre
livre1 = {}
livre1['titre'] = 'Apprendre Python'
livre1['année'] = 2010
print(livre1['titre'])

# autre syntaxe pour un second livre
livre2 = { 'titre': 'Algorithmique' , 'année': 1970 }

# procédure dédiée à ce type
def affiche_livre (l):
  print('titre :',l['titre'])
  print('année :',l['année'])

# appel à la procédure sur le livre1
affiche_livre(livre1)

Opérations Python sur les dictionnaires :

• keys donne les clefs d'un dictionnaire,
• values donne les valeurs d'un dictionnaire,
• items fournit clefs et valeurs du dictionnaire sous forme de couples,
• len donne le nombre de couples dans le dictionnaire,
• get extrait la valeur associée à une clef, comme on le fait avec la notation crochets mais permet de prévoir une valeur par défaut pour le cas où la clef n'existe pas dans le dictionnaire,
• in dit si la clef existe ou non dans le dictionnaire,
• del permet de supprimer une entrée du dictionnaire.

# définition d'un dictionnaire
d = { 'Titi':'titi@univ.fr' , 'Toto':'toto.truc@free.fr' }

print(d.keys())   # ['Toto', 'Titi']
print(d.values()) # ['toto.truc@free.fr', 'titi@univ.fr'] 
print(d.items())
# [('Toto','toto.truc@free.fr') , ('Titi','titi@univ.fr')]

# parcours de clefs et affichage des couples nom/mail
for nom in d:
    print(nom,':',d[nom])

print(len(d)) # affiche 2

print('Toto' in d) # True
print('Lulu' in d) # False

print(d['Toto']) # toto.truc@free.fr
print(d['Lulu']) # KeyError: 'Lulu'

print(d.get("Toto","contact inconnu")) # toto.truc@free.fr
print(d.get("Lulu","contact inconnu")) # contact inconnu

del(d['Toto']) # suppression des infos sur Toto
print(d.get("Toto","contact inconnu")) # contact inconnu

Lecture

Écriture

Voici les instructions Python de base pour créer un fichier texte :

# ouverture du fichier en écriture
f = open('monfichier.dat','w')

# écritures dans le fichier
f.write("coucou ! ") # on écrit coucou dans le fichier 
f.write(str(12))     # on convertit 12 en texte et on l'écrit 
f.write("\n")        # on passe à la ligne dans le fichier

f.close() # fermeture du fichier

write ne traite que des chaînes de caractères, nous devons donc convertir tout autre type de données en chaîne à l'aide de la fonction str.

Accès aux éléments d'un module

Plusieurs syntaxes sont possibles pour préciser les modules et les fonctions en provenance de ces modules que nous allons utiliser.

# on va utiliser des fonctions du module
import module
...
# on précise à nouveau le nom du module
# avec chaque utilisation d'une fonction de ce module
module.fonction()
...

# nous précisons la fonction qui nous intéresse
from module import fonction
...
# il n'est pas nécessaire de rappeler le nom du module
fonction()
...
# plusieurs fonctions nous intéressent...
from module import f1,f2
...
f1()
...
f2()
...
# toutes les fonctions du module nous intéressent...
from module import *
...
f1()
...
f2()
...
f3()
...

Gestion de l'aléatoire : le module random

• random.randint choisit aléatoirement un entier dans un intervalle donné,
• random.randrange choisit aléatoirement entre 0 et un entier donné (exclu), permet aussi de préciser une borne inférieure autre que 0 et un pas de progressions,
• random.choice fournit aléatoirement un élément parmi ceux d'une liste,
• random.shuffle mélange sur place les éléments d'une liste.

import random

print(random.randint(1,10))       # un entier entre 1 et 10

print(random.randrange(10))       # un entier entre 0 et 9
print(random.randrange(10,100,2)) # entier pair entre 10 et 98

notes = [5,12,8,20,10]            # on définit une liste

print(random.choice(notes))       # une note au hasard

print(notes)
random.shuffle(notes)             # mélange aléatoire
print(notes)

Les expressions régulières avec le module re

Les couleurs dans le terminal avec le module termcolor

Gestion du système : os et sys

os.listdir fournit la liste des fichiers dans un dossier donné.

Si nous avons un algorithme récursif qui nécessite d'augmenter le nombre de récursions autorisées, cela se fait de cette manière :

import sys
sys.setrecursionlimit(2000)

Mesure des temps de calcul : time

import time

t1 = time.process_time()
...
# ici les instructions à chronométrer
...
t2 = time.process_time()
print((t2 - t1),'sec.')

Déplacements d'une tortue : le module turtle

• color(c) et width(w) pour décider de la couleur et de l'épaisseur du trait,
• write(t) pour écrire un texte,
• up() et down() pour lever et baisser le crayon,
• forward(d) et backward(d) pour avancer et reculer d'une certaine distance,
• goto(x,y) pour se rendre à des coordonnées particulières,
• circle(r) pour dessiner un cercle de rayon donnée,
• begin_fill() et end_fill() pour colorier,
• hideturtle() et exitonclick() pour cacher la tortue et attendre un clic,
• speed(v) pour régler la vitesse de la tortue,
• reset() pour réinitialiser.

from turtle import *