Tutoriel N°2 : Instructions de base en python

Auteur : Pr. Abdelghani GHAZDALI

Table of Contents
1 Version de Python
2 Utilisation de IPython
2.1 Accès aux aides
2.2 Les clés magiques de IPython
3 Les bases du langage pour commencer à coder
3.1 Les principes
3.1.1 Typage des variables
3.1.2 Un langage tout objet
3.1.3 Les commentaires
3.1.4 Les opérateurs logiques
3.2 Les structures en Python
3.2.1 Les tuples
3.2.2 Les listes
3.2.3 Les chaînes de caratères
3.2.4 Les dictionnaires
3.3 Conditions / Boucles avec Python
3.3.1 Conditions
3.3.2 Opérateurs de comparaison
3.3.3 Les boucles
[Link] La boucle for
[Link] La boucle While
3.4 Les fonctions
3.4.1 Les valeurs par défaut des paramètres
3.4.2 L'utlisation de *args et **kwargs dans un appel de fonctions
3.4.3 Les docstrings
3.4.4 Les retours multiples
3.4.5 Les fonctions lambdas
3.5 Les classes
3.5.1 Comment reconnaître une classe
3.5.2 Définir une classe
3.6 Les modules et les packages
3.7 Aller plus loin
3.7.1 La gestion d'exceptions
3.7.2 Les expressions régulières
3.7.3 Les décorateurs
Pour ce tutoriel :
Présentations de quelques éléments de python base
Vous êtes évidemment libres de jouer un peu avec le notebook et de faire vos tests en cours de route.

Version de Python
Dans le cadre de ces notebooks (comme dans le cadre de l'ouvrage), nous faisons le choix d'utiliser Python 3 plutôt que
Python 2.
Si vous désirez comprendre les différences entre ces versions, je vous invite à consulter ce site :
 [Link]

Utilisation de IPython
Comme nous utilisons des notebooks Jupyter, nous utilisons l'interpréteur IPython par défaut.
Celui-ci nous apporte de nombreux avantages :
- Utilisation de la tabulation pour la complétion
- Utilisation des clés magiques
- Accès simplifié aux aides

Accès aux aides

Vous pouvez accéder aux aides en utilisant la combinaison Shift + Tab mais aussi en utilisant :
In [1]: sum?

Et pour accéder au code source d'une fonction lorsqu'il est disponible :

In [2]: sum??

Les clés magiques de IPython

IPython possède de nombreuses clés magiques, elles sont appelées dans un Notebook en utilisant le symbole %. Une clé
magique avec un % s'applique à une ligne, une clé magique avec %% s'applique à toute une cellule.
Pour obtenir la liste des clés magiques, on peut utiliser :
In [3]: %lsmagic

Out[3]: Available line magics:

%alias %alias_magic %autoawait %autocall %automagic %autosave %bookmark %cat %cd %clear %color
s %conda %config %connect_info %cp %debug %dhist %dirs %doctest_mode %ed %edit %env %gui %h
ist %history %killbgscripts %ldir %less %lf %lk %ll %load %load_ext %loadpy %logoff %logon
%logstart %logstate %logstop %ls %lsmagic %lx %macro %magic %man %matplotlib %mkdir %more %m
v %notebook %page %pastebin %pdb %pdef %pdoc %pfile %pinfo %pinfo2 %pip %popd %pprint %prec
ision %prun %psearch %psource %pushd %pwd %pycat %pylab %qtconsole %quickref %recall %rehashx
%reload_ext %rep %rerun %reset %reset_selective %rm %rmdir %run %save %sc %set_env %store %s
x %system %tb %time %timeit %unalias %unload_ext %who %who_ls %whos %xdel %xmode

Available cell magics:

%%! %%HTML %%SVG %%bash %%capture %%debug %%file %%html %%javascript %%js %%latex %%markdown
%%perl %%prun %%pypy %%python %%python2 %%python3 %%ruby %%script %%sh %%svg %%sx %%system %
%time %%timeit %%writefile

Automagic is ON, % prefix IS NOT needed for line magics.

Voici quelques clés magiques utiles :

In [4]: # Liste des objets chargés en mémoire
%whos

Interactive namespace is empty.

In [5]: # Timer pour mesurer le temps de traitement

%timeit 2**10

8.4 ns ± 0.252 ns per loop (mean ± std. dev. of 7 runs, 100000000 loops each)

Les bases du langage pour commencer à coder

Les principes
 Typage des variables
On commence par définir l'opérateur d'allocation qui est le =
In [6]: var1=1

Le typage étant automatique (duck typing), on définit le type en utilisant la valeur alouée :
In [7]: var1=10
var2=3.5
var3="Python"
var4=True
print(type(var1),type(var2),type(var3),type(var4))

<class 'int'> <class 'float'> <class 'str'> <class 'bool'>

Un langage tout objet

En Python, tous ce que nous allons utiliser sont des objets issus de classes. Ainsi ces objets ont les attributs et les
méthodes liées aux classes.
Ainsi pour une chaîne de caractères :
In [8]: chaine1="Python"
# on utilise une méthode de la classe str :
print([Link]())

PYTHON

Les commentaires
En Python les commentaires sont indiqué par le signe #.
Ils peuvent être sur une ligne complète ou après le code
Les opérateurs logiques
Pour tester un type, on peut utiliser :
In [9]: type(chaine1) is str

Out[9]: True

In [10]: entier1=44

In [11]: type(chaine1) is type(entier1)

Out[11]: False

Les structures en Python

Il existe plusieurs structures en Python : les tuples, les listes et les dictionnaires en sont les pricipales.
Les tuples
In [12]: # on définit un tuple avec ()
tup1=(1, True, 7.5,9)

In [13]: # on accède à un élément d'un tuple (et de n'importe quelle structure) avec []
tup1[2]

Out[13]: 7.5
In [14]: # les tuples possèdent peu de méthodes
[Link](9)

Out[14]: 1

Les listes
Les listes sont définies avec des [] et peuvent être constitués de tous les types d'objets
In [15]: list1=[3,5,6, True]

On accède à un élément d'une liste en utilisant []:

In [16]: list1[0]

Out[16]: 3

In [17]: # On peut facilement accéder à plusieurs éléments de différentes façons

list1[0:2] == list1[:2]

Out[17]: True

In [18]: # Extraire le dernier élément

list1[-1]

Out[18]: True

In [19]: # Extraire les 3 derniers éléments

list1[-3:]

Out[19]: [5, 6, True]

Voici un exemple de listes avec des chaînes de caractères

La liste possède de nombreuses méthodes, ici on utilise une inversion des éléments.
In [20]: liste_pays=["Chine","Inde","Etats-Unis","France","Espagne","Suisse"]
print(liste_pays[:3])
print(liste_pays[-3:])
liste_pays.reverse()
print(liste_pays)

['Chine', 'Inde', 'Etats-Unis']

['France', 'Espagne', 'Suisse']
['Suisse', 'Espagne', 'France', 'Etats-Unis', 'Inde', 'Chine']

Les list comprehension sont des générateurs de listes qui utilisent des conditions et des boucles.
Dans cet exemple, on va extraire le carré des éléments pairs de la list_init
In [21]: list_init=[4,6,7,8]
list_comp=[val**2 for val in list_init if val % 2 == 0]
print(list_comp)

[16, 36, 64]

Les chaînes de caratères

On a trois façons équivalentes de définir des chaînes de caractères
In [22]: chaine1="Python pour le data scientist"
chaine2='Python pour le data scientist'
chaine3="""Python pour le data scientist"""

Une chaîne de caractère est en fait une liste spécifique dans laquelle chaque élément est un caractère
In [23]: print(chaine1[:6])
print(chaine1[-14:])
 print(chaine1[15:20])

Python
data scientist
data

On peut facilement passer d'une chaîne de caractères à une liste

In [24]: # on sépare les éléments en utilisant l’espace
liste1=[Link]()
print(liste1)

['Python', 'pour', 'le', 'data', 'scientist']

In [25]: # on joint les éléments avec l’espace

chaine1bis=" ".join(liste1)
print(chaine1bis)

Python pour le data scientist

Les dictionnaires
Les dictionnaires permettent de stocker des éléments en utilisant un système de clés.
In [26]: dict1={"cle1":"valeur1", "cle2":"valeur2", "cle3":"valeur3"}

In [27]: # on accède à un élément par sa clé

dict1["cle2"]

Out[27]: 'valeur2'

In [28]: # on peut afficher la liste des clés

[Link]()

Out[28]: dict_keys(['cle1', 'cle2', 'cle3'])

In [29]: # on peut aussi afficher les pairs clé : valeur

[Link]()

Out[29]: dict_items([('cle1', 'valeur1'), ('cle2', 'valeur2'), ('cle3', 'valeur3')])

In [30]: # on crée une clé et a valeur associée :

dict1["cle4"]="valeur4"

In [31]: # on peut supprimer cette clé

del dict1["cle4"]

In [32]: # on peut aussi utiliser la fonction dict :

dict2=dict(cle1="valeur1",cle2="valeur2")

In [33]: dict2["cle1"]

Out[33]: 'valeur1'

Conditions / Boucles avec Python

Conditions
Les conditions sont simples à mettre en place en Python
In [34]: # on définit a
a=True

In [35]: # première condition

if a is True :
print("c'est vrai")

c'est vrai
In [36]: # on ajoute une alternative
if a is True :
print("c'est vrai")
else :
print("ce n'est pas vrai")

c'est vrai

In [37]: # on ajoute un elif

if a is True :
print("c'est vrai")
elif a is False :
print("c'est faux")
else :
print("ce n'est pas un booléen")

c'est vrai

Opérateurs de comparaison
On peut utiliser en Python == ou is et leur utilisation sera différente
In [38]: # True est égal à 1
True == 1

Out[38]: True

In [39]: # False est égal à 0

False == 0

Out[39]: True

In [40]: # mais True n'est pas 1 (objet différent)

True is 1

<>:2: SyntaxWarning: "is" with a literal. Did you mean "=="?

<>:2: SyntaxWarning: "is" with a literal. Did you mean "=="?
/var/folders/9g/23ddh85j1g5f7c_hrsh_n6_r0000gn/T/ipykernel_21209/[Link]: SyntaxWarning: "is" with
a literal. Did you mean "=="?
True is 1
Out[40]: False

In [41]: # en comparaisons True est plus grand que False (1>0)

True > False

Out[41]: True

In [42]: # pour des chaînes de caractères, l’ordre alphabétique prime

"Python" > "Java"

Out[42]: True

In [43]: "Java"< "C"

Out[43]: False

Les boucles
La boucle for
La boucle for itère sur les éléments d'un objet.
Avec une liste on a :
In [44]: for elem in [1, 2]:
print(elem)

1
2
 La fonction range() permet de générer une suite d'entiers :
In [45]: print(list(range(5)))
print(list(range(2,5)))
print(list(range(2,15,2)))

[0, 1, 2, 3, 4]
[2, 3, 4]
[2, 4, 6, 8, 10, 12, 14]

Pour générer une boucle sur des entiers de 0 à 10, on utilise :

In [46]: for i in range(11) :
print(i,end="--")

0--1--2--3--4--5--6--7--8--9--10--

Attention, la dernière valeur est toujours exclue !

La fonction enumerate() permet de générer un indice en plus de la valeur de l'élement :
In [47]: for i, a in enumerate(liste_pays) :
print(i, a)

0 Suisse
1 Espagne
2 France
3 Etats-Unis
4 Inde
5 Chine

La fonction zip permet de joindre deux listes et de les parcourir "en parallèle"
In [48]: for jour, meteo in zip(["lundi","mardi"],["beau","mauvais"]) :
print(" % s, il fera % s" %([Link](), meteo))

Lundi, il fera beau

Mardi, il fera mauvais

On peut combiner enumerate et zip :

In [49]: for i, (jour, meteo) in enumerate(zip(["lundi","mardi"],["beau","mauvais"])) :
print(" % i : % s, il fera % s" %(i, [Link](), meteo))

0 : Lundi, il fera beau

1 : Mardi, il fera mauvais

La boucle While
Cette boucle a un fonctionnement classique en Python :
In [50]: i=1
val_stop=50
while i<100 :
i+=1
if i>val_stop :
break
print(i)

51

Les fonctions
Il est très simple de définir des fonctions en Python
In [51]: def ma_fonc(a,b) :
print(a+b)

In [52]: # on a différentes approches pour appeler une fonction

ma_fonc(a=4, b=6)
 ma_fonc(4,6)
ma_fonc(b=6, a=4)

10
10
10

Les valeurs par défaut des paramètres

On peut définir des valeurs par défaut, ici on fixe b=6. Si b est renseigné dans l'appel, il prend la valeur renseignée, sinon il
prend la valeur par défaut.
In [53]: def ma_fonc_b(a, b=6) :
print(a+b)

In [54]: ma_fonc_b(2,5)
ma_fonc_b(2)

7
8

In [55]: def ma_fonc2(a, b=6, c=5, d=10) :

print(a+b+c+d)

In [56]: ma_fonc2(2, c=3)

ma_fonc2(2, d=1)

21
14

Lorsqu'on a plusieurs paramètres dans un appel de fonction, plutôt que d'appeler séparément les éléments, on peut fournir
une liste à la fonction.
Dans ce cas on utilisera *list :
In [57]: list_fonc=[3,5,6,8]
ma_fonc2(*list_fonc)

22

On peut aussi utiliser un dictionnaire et on utilise **dico :

In [58]: dico_fonc={"a":5,"b":6,"c":7,"d":5}
ma_fonc2(**dico_fonc)

23

L'utlisation de *args et **kwargs dans un appel de fonctions

Ceci va permettre d'avoir un nombre indéfini de paramètres dans l'appel de la fonctions.
*args est associé à une liste et **kwargs à un dictionnaire (c'est les * qui comptent et non les noms des arguents)
In [59]: def ma_fonc3(param_obligatoire,*args,**kwargs) :
print("Argument obligatoire :", param_obligatoire)
# si on a des arguments positionnés après les arguments obligatoires
# on les affiche
if args :
for val in args :
print("Argument dans args : ", val)
# si on a des arguments du type arg1 =… situé après les arguments
# obligatoires, on les affiche
if kwargs :
for key, val in [Link]() :
print("Nom de l’argument et valeur dans kwargs", key, val,sep=": ")

In [60]: ma_fonc3("DATA","Science","Python", option="mon_option")

 Argument obligatoire : DATA
Argument dans args : Science
Argument dans args : Python
Nom de l’argument et valeur dans kwargs: option: mon_option

In [61]: ma_fonc3("DATA", autre_option="mon_option")

Argument obligatoire : DATA

Nom de l’argument et valeur dans kwargs: autre_option: mon_option

Dans ce code, on a combiné les différentes options. On utilise souvent ce type d’arguments lorsqu’on appelle des fonctions
de manière imbriquée de manière à éviter d’avoir à nommer tous les paramètres de toutes les fonctions appelées. Bien
entendu, c’est à l’utilisateur de bien nommer les paramètres dans la partie kwargs
Les docstrings
Les docstrings consistent en des descriptions des fonctions, des classes ou des modules que l'on définit en utilisant """ """
dans la ligne suivant la définition de la fonction / classe / module :
In [62]: def ma_fonction(*args):
"""Cette fonction calcule la somme des paramètres"""
if args:
return sum(args)
else:
return None

In [63]: help(ma_fonction)

Help on function ma_fonction in module __main__:

ma_fonction(*args)
Cette fonction calcule la somme des paramètres

Pour une description des bonnes pratiques en terme d'utilisation des docstrings, je vous conseile la lecture de PEP 257 :
[Link]
Les retours multiples
Il est possible d'avoir plusieurs objets dans un return de fonctions. Dans ce cas ces différents éléments sont soit stockés
dans un tuple, soit associé à différents objets.
In [64]: def ma_fonc(a, b) :
return a+b, a-b

In [65]: tu1=ma_fonc(2,5)
print(tu1)
val1, val2=ma_fonc(2,5)
print(val1, val2)

(7, -3)
7 -3

Les fonctions lambdas

Il s'agit de fonctions anonymes qui s'écrivent en une seule ligne.
En voici deux exemples :
In [66]: ma_chaine="Python pour le data scientist"
(lambda chaine : [Link]().split())(ma_chaine)

Out[66]: ['PYTHON', 'POUR', 'LE', 'DATA', 'SCIENTIST']

In [67]: ma_liste = [1, 6, 8, 3, 12]

nouvelle_liste = list(filter(lambda x: (x >= 6), ma_liste))
print(nouvelle_liste)
 [6, 8, 12]

Les classes
Comment reconnaître une classe
On reconnaît une classe car, en principe, elle s'écrit avec des majuscule et sans séparateurs.
On aura : KMeans() est une classe
Définir une classe
On définit simplement des classes en Python
In [68]: class MonImage:
def __init__(self, resolution = 300, source = "./", taille= 500) :
[Link] = resolution
[Link] = source
[Link] = taille

In [69]: # on crée un objet de la classe qu'on a créé plus haut

image_1 = MonImage(source="../other/[Link]",
taille=500)

En plus du constructeur __init__(), on va ajouter des méthodes :

In [70]: class MonImage:
def __init__(self, resolution = 300, source = "./", taille= 500) :
[Link]=resolution
[Link]=source
[Link]=taille

def affiche_caract(self):
print("Résolution:", [Link])
print("Taille:", [Link])
print("Source:", [Link])

def agrandir_image(self, facteur) :

[Link]*= facteur

In [71]: # on applique une méthode sur notre objet

image_1 = MonImage(source="../other/[Link]",
taille=500)
image_1.agrandir_image(2)
print(image_1.taille)

1000

Je vous conseille fortement d'approfondir la notion de classe, centrale dans la programmation orientée objet de Python.
La notion d'héritage est extrêmement importante et vous servira dès que vous serez un développeur plus aguérri.
De nombreuses références sont disponibles sur le web et à la fin de l'ouvrage.

Les modules et les packages

On peut importer simplement des packages dans un notebook ou dans un script
In [72]: import datetime

In [73]: print([Link]())

2024-05-14

On donne souvent des noms courts aux packages :

In [74]: import numpy as np
In [75]: print([Link](1))

[0.30904292]

On peut aussi importer une classe ou une fonction spécifiquement :

In [76]: from pandas import DataFrame

La création de package et de module est simple en Python, référez-vous à la partie à ce sujet dans l'ouvrage ou à la
documentation de Python ici :
[Link]

Aller plus loin

La gestion d'exceptions
Il est souvent nécessaire de gérer les erreurs qui peuvent être présentes dans un programme.
In [77]: def rapport(x, y) :
try:
return x/y
except ZeroDivisionError :
print("Division par zéro")
return None
except TypeError :
print("Le type entré ne correspond pas")
return None

In [78]: def rapport2(x, y) :

try:
resultat = x/y
except ZeroDivisionError:
print("Division par zéro")
else:
print("Le résultat est %.2f" %(resultat))
finally:
print("Le calcul est terminé")

In [79]: rapport2(1,2)

Le résultat est 0.50

Le calcul est terminé

In [80]: rapport2(1,0)

Division par zéro

Le calcul est terminé

Dans ce cas, l'erreur est affiché mais le programme execute quand même ce qui se trouve après finally
In [81]: rapport2("&", 3)

Le calcul est terminé

---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
/var/folders/9g/23ddh85j1g5f7c_hrsh_n6_r0000gn/T/ipykernel_21209/[Link] in <module>
----> 1 rapport2("&", 3)

/var/folders/9g/23ddh85j1g5f7c_hrsh_n6_r0000gn/T/ipykernel_21209/[Link] in rapport2(x, y)
1 def rapport2(x, y) :
2 try:
----> 3 resultat = x/y
4 except ZeroDivisionError:
5 print("Division par zéro")

TypeError: unsupported operand type(s) for /: 'str' and 'int'

Les expressions régulières

 Python possède un module re qui permet de travailler sur des chaînes de caractères en utilisant des expressions réguières.
Ce code illustre un cas où l'on chercherait à tester la présence d'une adresse email :
In [ ]: import re
chaine = "info@[Link]"
# on vérifie qu'il y a bien le signe @ et on vérifie que l'adresse se termine
# oar .fr ou .com
regexp = "(^[a-z0-9._-]+@[a-z0-9._-]+\.[(com|fr)]+)"
if [Link](regexp, chaine) is not None :
print("Vrai")
else:
print("Faux")

Les décorateurs
Il s'agit d'utiliser des fonctions de fonctions. Vous pouvez consulter l'ouvrage pour plus de détails.
In [ ]: def bonjour() :
return "Bonjour !"

def bonjour_aurevoir(fonction) :
print(fonction(), "Au revoir !", sep="\n")

bonjour_aurevoir(bonjour)

In [ ]: # on définit le décorateur - vérification du nom d’utilisateur

def test_utilisateur(fonction) :
def verif_utilisateur(*args) :
if args[0]=="Emmanuel" :
fonction(*args)
else :
print("Mauvais utilisateur")
return verif_utilisateur

In [ ]: # on définit un mauvais utilisateur avec le bon password

utilisateur="Paul"
password_emmanuel="Python"

In [ ]: # on définit la fonction affiche_mot_de_passe qui affiche le mot de

# passe que si l’utilisateur est Emmanuel en utilisant le décorateur
@test_utilisateur
def afficher_mot_de_passe(utilisateur) :
print("Mon mot de passe est % s" %(password_emmanuel))

In [ ]: # on appelle la fonction décorée

afficher_mot_de_passe(utilisateur)

In [ ]: # on change d’utilisateur
utilisateur="Emmanuel"
afficher_mot_de_passe(utilisateur)

Ce notebook ne constitue qu'un avant-goût de toutes les possibilités de Python.

De nombreuses autres ressources vous permettrons de compléter vos compétences en Python