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. C'est la règle générale mais nous verrons qu'il est possible d'écrire une chaîne de caractères ou une condition sur plusieurs lignes pour une bonne lisibilité du code Python.

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, il faut utiliser un éditeur qui, après un appui sur la touche tabulation du clavier, amène le curseur à l'endroit adéquat en produisant le nombre d'espaces nécessaires.

Types et variables

Python autorise la manipulation de types classiques : booléens (bool), entiers (int), réels (float) et chaîne de caractères (str). À noter que les noms des types indiqués sont aussi des opérateurs de conversion.

Ni les variables ni leurs types n'ont besoin d'être déclarés.

pi    = 3.14    # déclaration et affectation d'un nombre
msg   = 'toto'  # affectation d'une chaîne de caractères
txtpi = str(pi) # obtention de la chaîne de caractères "3.14"

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. Nous verrons que des commentaires bien formatés permettent la production de commentaires et des tests automatiques.

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
'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).

i     = 10
i     = i + 8

Nous retrouvons également les habituels opérateurs logiques (and, or et not) pour manipuler les booléens qui, en Python, sont notés True et False.

Premières chaînes de caractères et instruction d'affichage

En Python, les chaînes de caractères doivent être délimitées, au choix, par des apostrophes ou des guillemets.

"coucou hé !"
'ça va ?'

La manipulation des chaînes de caractères en Python dans une section dédiée.

Les affichages sont en Python réalisés à l'aide de l'instruction print() : elle affiche les éléments qu'on lui confie puis passe à la ligne, les éléments sont séparés par un espace.

print("coucou hé !")  # affiche et passe à la ligne
print("toto","titi")  # titi suit toto, passage à la ligne
print()               # simple passage à la ligne

En fait, le passage à la ligne en fin d'affichage et l'espace séparateur sont des paramètres du print que l'on peut modifier. Voici quelques exemples qui illustrent différentes utilisations possibles de print.

print("toto",end="!")        # termine par un ! et pas par un passage à la ligne
print("titi")                # titi s'ajoute à toto et passage à la ligne
print("lulu","lala",sep="+") # affiche lulu+lala et passe à la ligne

On note qu'en Python un paramètre peut être optionnel avec une valeur par défaut. Et que les paramètres peuvent être nommés au moment d'un appel à une procédure, on se dispense ainsi de l'ordre fixé dans la définition de la procédure.

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...')

Caractère \ pour échapper la fin de ligne et mettre en forme par exemple un conjonctions de tests dans un if sur plusieurs lignes pour la lisibilité. Donner un exemple.

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

Basée sur range qui peut prendre jusqu'à trois arguments.

La fonction range permet de définir un intervalle, intervalle que l'on parcourt à 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)

Une utilisation plus générale de cette boucle est possible pour parcourir les éléments d'une séquence quelconque, par exemple une chaîne de caractères.

Écriture des chaînes de caractères en Python

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 ?")

utilisation du caractère d'échappement backslash pour utiliser ' ou " ou... \ ! \n ou \t pour ajouter saut de ligne ou tabulation

print('oui, ça va aujourd\'hui !')  # échappement de l'apostrophe grâce au backslash
print("\t super !")                 # ajout d'une tabulation en début de ligne

Autre solution : les raw strings ou chaînes brutes : r"...". Elles neutralisent le caractère d'échappement \ qui redevient un caractère quelconque. Ajouter exemple.

msg = "\n" ou msg = r"\n" : len(msg) donne respectivement 1 et 2 msg dans la console donne respectivement \n et \\n print(msg) donne respectivement une ligne blanche et \n

Python autorise les chaînes de caractères de sur plusieurs lignes... triple guillemet """ pour une chaîne sur plusieurs lignes. Ajouter exemple.

Codage des caractères

chr/ord : versions unicode en python3 ?

Il est possible de repérer un caractère par son numéro UNICODE. Par exemple, les lettres de a à z en minuscules correspondent aux codes de 97 à 122. La fonction Python chr permet de passer de l'entier au caractère correspondant, la fonction ord réalise la conversion inverse.

print(chr(100)) # affichage du caractère 100, c'est un 'd'
print(ord('m')) # affiche le code UNICODE du 'm' : 109

Opérations sur les chaînes de caractères en Python

comparaison de chaînes de caractères avec < et > (attention comparaison des codes UNICODE des caractères)

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),

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

len() pour obtenir la longueur d'une chaîne de caractères. .lower ? .upper ? .rstrip ? .join() pour ajouter les caractères d'une liste à une chaîne.

extractions les slices.

parcours d'une chaîne de caractères avec for in

# 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 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. Donner des exemples ?

substitutions ? avec les slices.

Formatage des chaînes de caractères

formatage

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')

À rappeler. En Python un paramètre peut être optionnel avec une valeur par défaut. Les paramètres peuvent être nommés au moment de l'appel à une procédure, on se dispense ainsi de l'ordre fixé dans la définition de la procédure.

À dire aussi. Nous verrons que des commentaires bien formatés permettent la production de commentaires et des tests automatiques.

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)

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

Encourager l'utilisation des espace de noms.

Plusieurs syntaxes sont possibles pour préciser les modules et les procédures/fonctions en provenance de ces modules.

# 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()
...

Écriture

Voici les instructions Python de base pour créer un fichier texte : voir le print avec précision du flux dans lequel écrire.

# ouverture du fichier en écriture
flux_out = open('horla.html',mode='w',encoding="utf-8")

print("

",file=flux_out)
    
flux_out.close()

À oublier ? 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.

# é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

Lecture

À rédiger.

flux_in = open('horla.txt',mode='r',encoding="utf-8")

# for ligne in flux_in:
while ligne := flux_in.readline():
    ligne = ligne.rstrip()
    
flux_in.close() # fermeture du fichier

voir aussi lecture flux pipe

Premiers dictionnaires

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 la valeur 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

Test d'existence et comptage à l'aide des dictionnaires Python

À rédiger.

Documentation et tests automatiques : le module doctest

À développer. Lors de la définition d'une procédure/fonction, on peut ajouter après la première ligne une docstring. Il s'agit d'une chaîne de caractères, délimitée par des triples guillemets, qui décrit la fonction et propose des tests à travers des exemples d'utilisation.

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)

Expressions régulières : le module re

À rédiger.

expressions régulières exprimées comme des chaînes de caractères : il faut utiliser les raw strings. À détailler.

Couleurs dans le terminal : le module termcolor

À rédiger.

Langues et localisations : le module locale

À rédiger.

pb accents dans les tris, expliquer strcoll, strxfrm

import locale
locale.setlocale(locale.LC_ALL,"")            # soit locale par défaut de la machine
locale.setlocale(locale.LC_ALL,"fr_FR.UTF-8") # soit on précise la locale voulue

locale.localeconv()["int_curr_symbol"] # symbole monétaire à utiliser d'après la locale

l = ["favori","école","abri"]
sorted(l,key=locale.strxfrm)
['abri', 'école', 'favori']

Manipulation des documents XML : le module xml

SAX et DOM. À rédiger.

DOM : voir l'API DOM dans le cours de JavaScript.

Nous nous concentrons ici sur le noyau de DOM fournissant des méthodes valables pour tout document XML (en particulier, des documents non-HTML) et les exemples sont donnés en Python).

En Python, le programme minimal qui charge un document XML sous forme de DOM est le suivant :

from xml.dom.minidom import parse

dom = parse("fichier.xml")

Ou, si l'on souhaite lire le nom du fichier depuis la ligne de commande :

from xml.dom.minidom import parse
import sys

xmlfilename = sys.argv[1]
dom         = parse(xmlfilename)

Premiers exemples de programmes Python & DOM

from xml.dom.minidom import parse
import sys

xmlfilename = sys.argv[1]
dom         = parse(xmlfilename)

titres  = dom.getElementsByTagName("titre")
premier = titres[0]
texte   = premier.childNodes[0]

print(texte.nodeValue)

from xml.dom.minidom import parse
import sys

xmlfilename = sys.argv[1]
dom         = parse(xmlfilename)

sites = dom.getElementsByTagName('site')

for site in sites:
    attrs   = site.attributes
    urlnode = attrs['url']
    print(urlnode.nodeValue)

from xml.dom.minidom import parse
import sys

xmlfilename = sys.argv[1]
dom         = parse(xmlfilename)

racine = dom.documentElement;
fils   = racine.childNodes

print('racine=',racine.nodeName)

for f in fils:
  if f.nodeType==1:
    print(f.nodeName,'=',f.childNodes[0].nodeValue)

Un nouveau DOM

impl        = getDOMImplementation()
newdoc      = impl.createDocument(None,"laracine",None)
top_element = newdoc.documentElement

Définir un nœud ou un attribut

new_element = newdoc.createElement('nomelement')
new_element.setAttribute('nom_attribut','valeurattribut')

copie = noeud.cloneNode(True)
copie.removeAttribute('nom_attribut_à_supprimer')

Placer un nœud dans la structure

top_element.appendChild(new_element)

Produire du XML

Produire du XML à partir d'un nœud n : n.toxml() ou n.toprettyxml().

newdoc.toxml()
newdoc.toprettyxml()

Traitement automatique des langues : le module nltk

À rédiger.

Échanges avec le système d'exploitation : le module os

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

Récupération du flux produit par un autre programme.

import os
pipe = os.popen('ls -l ~')

while ligne := pipe.readline():
    print(ligne,end="")

Interaction avec l'interprète Python : le module sys

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 : le module 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 *