Tutoriel Python – Le KrocK

Ce document est un tutoriel sur le language de programmation Python, plus précisément, Python 3. L’information est plus ou moins un résumé du tutoriel disponible sur le site officiel de Python.

Le but de ce document N’EST PAS de fournir de l’information détaillée sur toutes les possibilités du language mais plutôt de faire un survol des principales fonctionnalités pour apprendre rapidement à faire des scripts simples. Ce document s’adresse plus particulièrement aux personnes qui connaissent déjà au moins un autre language et qui cherchent à apprendre à programmer en Python rapidement.

Les exemples et le contenu prennent donc pour aquis que le lecteur maîtrise déjà les concepts de base de la programmation. (Par exemple, je n’expliquerai pas ce qu’est une boucle, mais j’expliquerai comment en écrire une en language Python)

Pour la documentation complète, veuillez visiter le site officiel de Python, où vous pourrez en apprendre plus à propos du language et de la philosophie qui le propulse.

Même si j’ai testé chaque instruction et révisé le document plusieurs fois, il peut tout de même y rester quelques erreurs, si vous trouvez de l’information erronée ou un bout de code qui ne fonctionne pas, envoyez-moi un courriel à contact@lekrock.com et je le corrigerai.

La programmation se fait généralement avec des outils anglophones, la traduction est donc difficile pour certains termes et concepts. La règle que j’ai suivie tout au long de ce tutoriel est de traduire les concepts dans la mesure du possible tout en gardant les références aux mots-clés et particularités du langage dans leur langue originale anglaise. Le code propre au programmeur tel que les noms de variables, de fonctions et les chaînes de caractères seront en français, par-contre, seulement le contenu des chaînes de caractères et des commentaires contiendra des accents.

Notes importantes

La première ligne de tout fichier Python doit spécifier où se trouve l’exécutable Python (comme dans un script Unix).

#!/usr/bin/python

#!/usr/local/bin/python

L’extension de fichier d’un script Python est «.py».

Dans l’environnement Linux/Unix, le script doit être défini en tant qu’exécutable (comme un script Bash).

chmod +x monscript.py

chmod 755 monscript.py

Python utilise l’indentation plutôt que les accolades, un bloc de code est donc délimité par son indentation, ceci est aussi vrai pour le mode interactif. (Le fait qu’il y aie un espace devant la première ligne de chaque bloc de code de ce tutoriel est involontaire, cela semble être un bug de présentation et il n’est donc pas nécessaire de le faire dans vos propres scripts)

# Ceci est une fonction
def maFonction():
     print('Ceci est un message')    # L'indentation de cette instruction signifie qu'elle fait partie de "maFonction"

# Ceci est un appel de fonction
# Cet appel de fonction ne fait pas partie de "maFonction" car il n'est pas indenté
maFonction()

Python est sensible à la casse, alors «var» et «Var» seront deux variables différentes.

var = 1
Var = 2

print(var, Var)

# Affichera (sans guillemets): "1 2"

Dans les structures de type tableau, le premier index est 0 (zéro).

maChaine = "abc"
print(maChaine[0])

# Affichera (sans guillemets): "a"

Lorsqu’une série de valeurs est utilisée, l’interpréteur accepte que la dernière valeur soit aussi suivie d’une virgule.

maListe = ['a', 'b', 'c',]

Mode interactif

Un appel à l’exécutable Python dans un terminal démarrera Python en mode interactif.

Le mode interactif permet d’exécuter des commandes Python à volonté et d’en voir directement l’effet. Tout ce qui peut être écrit dans un script peut l’être en mode interactif, incluant les instructions multi-lignes, les fonctions, les boucles et les classes. Les règles d’indentation doivent être appliquées de la même façon que dans un script.

Structures de base du code

Un commentaire débute par un «#». Il n’est PAS essentiel de suivre le dièse d’un espace ou d’une tabulation lors de l’écriture d’un commentaire, mais chaque commentaire dans ce tutoriel en contiendra un pour améliorer la lisibilité.

# Ceci est un commentaire

Opérateurs arithmétiques:

Addition: +
Soustraction: –
Multiplication: *
Division: /
Division arrondie vers le bas: //
Reste: %
Puissance: **

Types de données primitifs (les plus utilisés):

Entier (Integer)
Virgule flottante (Float)
Booléen (Boolean)
Octets (Bytes)
Chaîne de caractère (String)

L’assignation de valeur se fait avec le symbole «=», comme on pourrait si attendre.

v = 1 + 2

L’assignation multiple est aussi possible.

v1, v2 = 1, 2

L’absence de valeur, qui est souvent définie par «null» ou «nil» dans d’autres langages, est définie par «None» en Python.

L’affichage de texte à l’écran (dans une console) se fait avec la fonction «print()».

print("Bonjour monde!")

Chaînes de caractères

Il est possible de définir des chaînes de caractères autant avec les guillemets simples qu’avec les guillemets doubles.

Le caractère d’échappement est l’anti-slash (\) avec les deux types de guillemets.

Il est possible de concaténer des chaînes avec «+».

langage = "Python"
print('J\'utilise le langage ' + langage + "!")

# Affichera (sans guillements): "J'utilise le langage Python!"

Sous-chaînes

Le «slicing» permet d’obtenir une partie d’une chaîne de caractères.

langage = 'Python'
print(langage[2:4])

# Affichera (sans guillements): "th"

Longueur de chaîne

La fonction «len()» retournera la longueur de la chaîne de caractères passée en paramètre.

if len(langage) == 0:
    print("Chaîne vide!")

Caractères

Un caractère est une chaîne de caractères de longueur 1.

Il est possible d’accéder à n’importe quel caractère à l’intérieur d’une chaîne en faisant référence à sa position dans la chaîne.

langage = 'Python'
print(langage[1])

# Affichera (sans guillemets): "y"

Conditions et structures

Zéro (0) est considéré comme «False» (faux) et toutes les autres valeurs sont «True» (vraies). Veuillez noter qu’en utilisant les valeurs booléenes par leur «nom» (True et False), leur première lettre doit être en majuscule.

Opérateurs de comparaison:

Plus petit: <
Plus petit ou égal: <=
Plus grand: >
Plus grand ou égal: >=
Égal: ==
Différent: !=

Les objets peuvent être comparés avec «is» et «is not», plutôt qu’avec «==» et «!=».

Il est possible de combiner plusieurs comparaisons en utilisant «and» (et) et «or» (ou).

Le résultat d’une comparaison peut être assigné à une variable.

Le mot-clé «not» (non) peut être utilisé pour inverser une valeur booléenne.

maValeur = True
if maValeur == True:
    maValeur = not maValeur

# maValeur deviendra "False"

if

La condition «if» (si) est similaire à celle des autres langages connus.

x = 0
if x == 0:
    print('x est égal à zéro')
elif x > 0:
    print('x est positif')
else:
    print('x est négatif')

# Affichera (sans guillemets): "x est égal à zéro"

Switch

Le «switch» n’existe pas en Python, une combinaison de multiples if/elif sera nécessaire pour obtenir le même effet.

Informations générales à propos des boucles

Il est possible de sortir prématurément d’une boucle avec le mot-clé «break».
Le mot-clé «continue» permet de sauter directement à la prochaine itération.
Le mot-clé «else» permet d’exécuter du code à la fin d’une boucle qui ne s’est pas terminée par un «break».

while

La boucle while (jusqu’à/tant que) fonctionne de manière semblable à celle du while des autres langages.

i = 0
while i < 10:
    print(i)
    i += 1

for

La boucle «for» (pour) fonctionne à la manière d’un «for each» (pour chaque).

mots = ['Ceci', 'est', 'une', 'séquence']
for mot in mots:
    print(mot)

Il est aussi possible de faire une boucle traditionnelle sur une série de chiffres en utilisant la fonction «range()».

for i in range(10):
    print(i)

pass

Cette instruction ne fait absolument rien, elle peut être utilisée lorsqu’il est nécessaire d’ajouter une structure sans y mettre de code.

Fonctions

Information générale

Toutes les fonctions retournent une valeur même s’il n’y a aucune instruction «return», dans ce cas la valeur sera «None».

def maFonction(mot):
    print(mot)

Les fonctions Python peuvent retourner plusieurs valeurs, celles-ci doivent être séparées par des virgules dans l’instruction «return». Du côté où on reçoit le retour de l’appel de fonction, il est possible d’assigner chaque valeur à une variable distincte, ou de toutes les insérer dans un tuple.

def plusEtMoins(n1, n2):
    return n1 + n2, n1 - n2    # Cette fonction retourne le résultat d'une addition et d'une soustraction

r1, r2 = plusEtMoins(5, 3)    # Ici on reçoit les valeurs dans deux variables
t1 = plusEtMoins(4, 2)        # Ici t1 sera un tuple qui contiendra les deux résultats

Une fonction peut être renommée en l’assignant à une variable (ce qui devient pratique lorsqu’on utilise des modules).

utile = monModule.maFonctionUtile

Paramètres

Ils sont placés entre les parenthèses de la signature de la fonction comme dans plusieurs autres langages.

Il est possible de définir une valeur par défaut en assignant une valeur au paramètre dans sa définition. Une fois qu’on a défini un paramètre avec une valeur par défaut, tous les paramètres suivants doivent aussi en avoir une.

def maFonction(message='Ceci est le message par défaut.'):
    print(message)

Séquences

Information générale

Les séquences sont des conteneurs de type tableau, il en existe plusieurs types en Python et chacune d’elles possède des fonctionnalités qui lui sont propres.

Les mot-clés «in» et «not in» permettent de rechercher dans une séquence pour la présence ou l’absence d’un élément.

maValeur = 'valeur'
if maValeur in ('mot', 'chose', 'valeur'):
    print('Trouvé!')

Slices

Une slice est un interval de valeurs dans une séquence. Cela facillite la sélection de plusieurs valeurs. Le prochain exemple est très simple, référez-vous à la documentation officielle pour des exemples plus avancés de slicing.

L’index de départ est inclusif et l’index de fin est exclusif (il ne sera pas inclu dans les valeurs retournées).

mesLettres = ['a', 'b', 'c', 'd', 'e']
mesLettres[1:3]

# Affichera: ['b', 'c']

Index négatif

Utiliser une valeur négative comme index dans une séquence retournera l’élément correspondant à partir de la fin de la séquence. Cette méthode fonctionne aussi avec les slices.

Conversions de séquences

Une séquence peut être convertie en tuple avec la fonction «tuple()».
Une séquence peut être convertie en liste avec la fonction «list()».

Listes

Une liste est un groupe mutable de valeurs séparées par des virgules.

maListe = ['Ceci', 'est', 'une', 'liste']

Caractéristiques de la liste:

Peut contenir des valeurs de même type
La fonction «len()» retourne le nombre d’éléments
Des éléments peuvent être ajoutés avec la méthode «append()»
Peut contenir d’autres listes
Peut être utilisée comme une pile en utilisant les méthodes «append()» et «pop()»

Le mot-clé «del» permet de supprimer un élément à un index précis.

del maListe[0]

Tuples

Un tuple est un groupe non-mutable de valeurs séparées par des virgules.

monTuple = 'Ceci', 'est', 'un', 'tuple'

Caractéristiques d’un tuple:

Peut contenir des valeurs de types différents
Les valeurs peuvent être imbriquées
Peut contenir des listes (qui sont mutables)

Sets

Un set est une collection d’éléments qui contient seulement des valeurs uniques.

Caractéristiques d’un set:

Peut être créé avec la fonction «set()» ou avec les accolades «{}»

set1 = {'Ceci', 'est', 'un', 'set'}

set2 = set(['Ceci', 'est', 'un', 'autre', 'set'])

Le contenu est mutable
Peut être utilisé pour éliminer les doublons d’une autre séquence
Supporte les opérations comme «union», «intersection», «difference» et «symmetric» (en utilisant les opérateurs appropriés)

Dictionnaires

Un dictionnaire est une séquence contenant des paires de clé-valeur.

Caractéristiques d’un dictionnaire:

L’index (clé) peut être de n’importe quel type non-mutable (même des tuples si leur contenu n’est pas mutable)
Les clés doivent être uniques
Un dictionnaire vide peut être créé avec «{}»
Une valeur et son index peuvent être supprimés avec la fonction «del()»
Une liste de clés peut être obtenue avec la fonction «keys()»
Le mot-clé «in» permet de trouver une clé

monDictionnaire = {1: 'premier', 2: 'deuxième'}

Objets

Les méthodes d’un objet sont appellées en utilisant la notation pointée.

print(personne.nom)

with

Le bloc «with» peut être utilisé pour manipuler des ressources, il s’occupera de fermer celles-ci correctement à la fin du bloc peu importe l’issue (succès ou erreur).

with open('/home/quelquun/monfichier.txt', 'r') as fichier:
    contenuFichier = fichier.read()

Chaînes de documentation (Documentation strings)

Python permet d’auto-documenter le code, cela est fait en utilisant le triple-guillemet.

La chaîne de documentation doit être placée au début du bloc de code. La première ligne doit décrire ce que le code accompli de manière courte et précise.

S’il y a un besoin pour écrire plus d’une seule ligne, la deuxième ligne doit être laissée vide. Les lignes suivantes seront une explication plus en profondeur du code.

L’attribut «__doc__» contient le texte de la chaîne de documentation.

def maFonction():
    """Cette fonction est un exemple.

    Ceci est le reste du texte à propos de la fonction
    si besoin est.
    """
    print('Ceci est un exemple.')

print(maFonction.__doc__)

Modules

Les modules peuvent contenir du code prévu pour être réutilisé dans plusieurs autres scripts.

Un module se trouve dans un fichier Python et a aussi l’extension «.py».

Une liste de modules utiles se trouve à la fin de ce tutoriel.

Les modules sont importés avec la commande «import» suivie du nom du module à importer.

import monModule

Les importations de modules doivent être placées au début du fichier.

Le contenu d’un module est accessible avec la notation pointée.

monModule.maFonctionUtile()

Entrées et sorties

Chaînes de caractères

Il est possible de formater des chaînes de caractères avec la fonction «format()».

print("J'utilise la fonction {0}!".format('format'))

# Affichera (sans guillemets): "J'utilise la fonction format!"

L’alignement de colonne de chaînes de caractères peut être ajusté avec les fonctions «ljust()», «rjust()» et «center()».

Conversion en chaîne de caractères

La fonction «str()» convertie des valeurs lisibles par un humain en chaînes de caractères.

La fonction «repr()» convertie des valeurs non-lisibles par un humain (binaire par exemple) en chaînes de caractères lisibles par l’interpréteur.

Conversions de données

Pour convertir une chaîne de caractères en chiffre, il faut appeller le type numérique voulu comme une fonction et lui passer la chaîne en paramètre.

uneChaine = "8"
unEntier = int(uneChaine)

Pour convertir un chiffre en chaîne de caractères, il faut appeller la fonction «str()» et lui passer le chiffre en paramètre.

uneChaine = str(unEntier)

Fichiers

La fonction «open()» ouvre un fichier, le premier paramètre sera le nom du fichier et le deuxième paramètre sera le mode d’ouverture.

monFichier = open('/home/quelquun/unfichier.txt', 'r+')

Les modes d’ouverture de fichiers sont les suivants:

«r» pour lecture seule (option par défaut)
«w» pour écriture seule (efface le contenu du fichier si celui-ci n’est pas vide)
«a» pour concaténer à la fin du fichier
«r+» pour lecture et écriture

La fonction «read()» lit tout le fichier ou la longueur reçue en paramètres.

contenuFichier = monFichier.read()

La fonction «readline()» lit jusqu’au symbole «\n» et retourne une chaîne vide («») lorsque la fin du fichier est atteinte.

La fonction «write()» écrira le contenu reçu en paramètre dans le fichier.

monFichier.write('Du texte à écrire dans le fichier.')

La fonction «close()» ferme un fichier ouvert.

monFichier.close()

Exceptions et gestion des erreurs

Erreur de syntaxe

Comme dans plusieurs autres langages, Python dira à quelle ligne débute l’erreur dans le code.

Exceptions

Un bloc try/catch peut être utilisé pour attraper les exceptions, il attrapera aussi les exceptions déclenchées par les fonctions appellées à l’intérieur du bloc.

Le mot-clé «except» agit comme le «catch» et permet de gérer des types d’exceptions spécifiques de même que leur classe de base «Exception» pour attrapper toutes les exceptions.

Lorsqu’un «except» précise plusieurs types d’exceptions, on devra les énumérer dans un tuple.

Un bloc «else» peut être ajouté à la fin (après toutes les instructions «except») pour exécuter du code seulement dans le cas où aucune exception n’a été levée dans le bloc «try».

try:
    # Du code ici...
except NameError:
    print('Exception de type NameError.')
except (RuntimeError, TypeError):
    print('Exception de type RuntimeError ou TypeError')
except Exception:
    print("Une exception s'est produite.")
else:
    print('Tout est correct!')

Les exceptions peuvent être levées avec le mot-clé «raise», l’exception levée doit être de type «Exception» ou d’un type dérivé de celui-ci.

Un appel à «raise» sans type d’exception ou paramètre va re-lever l’exception courante.

raise Exception('Ceci est une exception!')

try:
    fonctionQuiPeutLeverUneException()
except Exception:
    raise

Le bloc «finally» peut être ajouté à la fin pour exécuter du code peu importe si une exception a été levée ou non, il est généralement utilisé pour libérer les ressources.

try:
    fonctionQuiPeutLeverUneException()
except Exception:
    raise
finally:
    print("Ceci est le bloc finally.")

Des exceptions personnalisées peuvent être créées, mais elles doivent absolument hériter de la classe «Exception».

Classes

Information générale

Python supporte les fonctionnalités de la programmation orientée objet.

Voici une liste de ce qu’une classe peut faire:

Héritage multiple
Surcharge de méthodes (toutes les méthodes)
Appel d’une méthode du même nom dans la classe de base
Peut contenir n’importe quel type et quantité de données
Peut être modifiée après sa création
Les membres normaux sont publiques (public)
Les classes sont des objets, ce qui signifie qu’elles peuvent être importées et renommées
Il est possible d’utiliser les types intégrés comme classes de base
Il est possible de redéfinir les opérateurs intégrés dans les instances de classes
Il est possible d’utiliser les alias (Utiliser plusieurs noms pour le même objet)

Les attributs sont référencés avec la notation pointée.

monObjet.uneMethode()

Les classes peuvent être instanciées simplement en appelant leur constructeur par défaut et en assignant la valeur retournée à une variable, cela crééra un objet vide. Pour initialiser un objet à l’instanciation, il faut définir une méthode «__init__()» à l’intérieur de la classe.

Le paramètre implicite (l’instance de l’objet qui appelle une de ses méthodes, l’équivalent de «this» dans certains autres langages), doit être défini par «self» et envoyé comme premier paramètre dans chaque méthode d’une classe.

class maClasse:
    def __init__(self):
        print("Initialiser l'objet.")
    def uneMethode(self, texte):
        print('Vous avez appellé la méthode uneMethode avec le texte: ' + texte + '.')

monInstance = maClasse()
monInstance.uneMethode("Du texte")

# Affichera (sans guillements): "Vous avez appellé la méthode uneMethode avec le texte: Du texte."

Les variables de classe n’ont pas besoin d’être déclarées, assigner une valeur au nom voulu suffit pour la créer.

monInstance.nouvelleVariable = 10
print(monInstance.nouvelleVariable)

# Affichera (sans guillements): "10"

Les variables d’instance doivent être déclarées dans la méthode «__init__()». Lorsqu’on réfère aux variables d’instance et aux méthodes d’une classe à l’intérieur de celle-ci, on doit les préfixer de «self.».

class maClasse:
    def __init__(self):
        self.maVariable = 0
        self.maListe = []

    def ajouterItem(self, item):
        self.maListe.append(item)

Une liste des méthodes et attributs d’un objet peut être obtenue en utilisant la fonction «dir()».

dir(monObjet)

Héritage

Pour hériter d’une autre classe, le nom de la classe de base doit être placé entre parenthèses après le nom de la classe dérivée. Les méthodes de la classe de base pourront être surchargées au besoin.

class maClasseDerivee(maClasseDeBase):

Les méthodes de la classe de base peuvent être appellées en faisant référence à la classe de base. Le paramètre «self» doit être passé explicitement.

maClasseDeBase.maMethode(self)

Il est possible de savoir si une classe hérite d’une classe de base en particuler avec la fonction «isinstance()», cette fonction peut aussi être utilisée avec les types intégrés de Python.

isinstance(monObjet, maClasseDeBase)

Librairie standard

Cette section contient une liste de modules utiles qui sont inclus avec l’installation de Python.

Module os

Il permet d’accéder à l’interface du système d’exploitation. Cela rend possible la gestion de fichiers, répertoires et des autres actions reliées au système de fichiers, ainsi que d’exécuter des commandes personnalisées avec la fonction «system()».

import os

os.system('echo Ceci est un message personnalisé.')

Module sys

Il permet, entre-autres, d’accéder aux paramètres de la ligne de commande et de rediriger «stdin», «stdout» et «stderr».

import sys

print('Paramètres de la ligne de commande: " + str(sys.argv))

Module re

Il permet d’utiliser les expressions régulières.

Module math

Il permet d’utiliser les fonctions C qui gèrent les nombres à virgule flottante.

Module random

Comme son nom le dit, il permet de générer des valeurs aléatoires.

Module statistics

Il inclut des fonctions permettant de calculer des valeurs statistiques comme la médiane, la variance, etc.

Module urllib

Il permet d’envoyer et de recevoir de l’information sur internet.

Manipulation de courriels

Les modules «email», «poplib» et «smtplib» permettent de traiter les courriels.

Module datetime

Évidement, il permet de gérer les dates et le temps.

Compression de données

Chaque format est accessible par son propre module.

Mesure de performances

Les modules «timeit», «profile» et «pstats» peuvent être utilisés pour mesurer la performance de segments ou d’instructions dans le code.

Contrôle de qualité

Le module «doctest» peut être utilisé pour écrire des tests directement dans la «docstring».

Le module «unittest» peut être utilisé pour faire des tests unitaires dans des fichiers distincts.

Données structurées

Les modules «json», «xml», «sqlite3» et «csv» peuvent être utilisés pour traiter leurs données respectives.

Autres modules

Le module «locale» permet de formater des données selon des localisations spécifiques.
Le développement «multi-thread» se fait avec le module «threading».
Le module «logging» offre les outils nécessaires à la manipulation de fichiers «log».
Le module «decimal» ajoute le type «decimal» qui permet de calculer des valeurs décimales en utilisant leur représentation exacte (contrairement aux nombres à virgule flottante standards qui sont représentés en binaire).
Le module «fractions» peut être utilisé pour gérer les calculs utilisant le type «decimal».
Le module «copy» permet de copier des objets avec ses fonctions «copy()» et «deepcopy()».