C1_python about:srcdoc
Chapitre 2 - Les bases de Python / Python
from scratch
Ce notebooks reprend les exemples de l'ouvrage Python pour le data scientist publié en
2018 chez Dunod. Il s'agit d'un notebook d'accompagnement que vous pourrez
réutiliser.
Ce chapitre consiste en un rappel des grands principes du langage Python.
2.1.2 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 di�érences entre ces versions, je vous invite à consulter
ce site :
[Link]
2.2 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?
Signature: sum(iterable, start=0, /)
Docstring:
Return the sum of a 'start' value (default: 0) plus an iterable of numbers
When the iterable is empty, return the start value.
This function is intended specifically for use with numeric values and may
reject non-numeric types.
Type: builtin_function_or_method
Et pour accéder au code source d'une fonction lorsqu'il est disponible :
1 of 15 11/13/25, 10:17
C1_python about:srcdoc
In [2]: sum??
Signature: sum(iterable, start=0, /)
Docstring:
Return the sum of a 'start' value (default: 0) plus an iterable of numbers
When the iterable is empty, return the start value.
This function is intended specifically for use with numeric values and may
reject non-numeric types.
Type: builtin_function_or_method
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 %boo
kmark %cd %clear %cls %colors %conda %config %connect_info %copy
%ddir %debug %dhist %dirs %doctest_mode %echo %ed %edit %env %g
ui %hist %history %killbgscripts %ldir %less %load %load_ext %lo
adpy %logoff %logon %logstart %logstate %logstop %ls %lsmagic %m
acro %magic %matplotlib %mkdir %more %notebook %page %pastebin
%pdb %pdef %pdoc %pfile %pinfo %pinfo2 %pip %popd %pprint %prec
ision %prun %psearch %psource %pushd %pwd %pycat %pylab %qtconso
le %quickref %recall %rehashx %reload_ext %ren %rep %rerun %rese
t %reset_selective %rmdir %run %save %sc %set_env %store %sx %s
ystem %tb %time %timeit %unalias %unload_ext %who %who_ls %whos
%xdel %xmode
Available cell magics:
%%! %%HTML %%SVG %%bash %%capture %%cmd %%debug %%file %%html %
%javascript %%js %%latex %%markdown %%perl %%prun %%pypy %%python
%%python2 %%python3 %%ruby %%script %%sh %%svg %%sx %%system %%t
ime %%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
20.8 ns ± 2.32 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops eac
h)
2.3 Les bases du langage pour commencer à coder
2 of 15 11/13/25, 10:17
C1_python about:srcdoc
2.3.1 Les principes
Typage des variables
On commence par dé�nir l'opérateur d'allocation qui est le =
In [6]: var1=1
Le typage étant automatique (duck typing), on dé�nit 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'>
2.3.2 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
2.3.3 Les commentaires
En Python les commentaires sont indiqué par le signe #.
Ils peuvent être sur une ligne complète ou après le code
2.3.6 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
3 of 15 11/13/25, 10:17
C1_python about:srcdoc
2.4 Les structures en Python
Il existe plusieurs structures en Python : les tuples, les listes et les dictionnaires en sont
les pricipales.
2.4.1 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
2.4.2 Les listes
Les listes sont dé�nies 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])
4 of 15 11/13/25, 10:17
C1_python about:srcdoc
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]
2.4.3 Les chaînes de caratères
On a trois façons équivalentes de dé�nir 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éci�que 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
2.4.4 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"}
5 of 15 11/13/25, 10:17
C1_python about:srcdoc
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', 'valeur
3')])
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'
2.5 Conditions / Boucles avec Python
2.5.1 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 :
6 of 15 11/13/25, 10:17
C1_python about:srcdoc
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 di�é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
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
2.5.2 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)))
7 of 15 11/13/25, 10:17
C1_python about:srcdoc
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
2.6 Les fonctions
8 of 15 11/13/25, 10:17
C1_python about:srcdoc
Il est très simple de dé�nir 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é�nir des valeurs par défaut, ici on �xe 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é�ni de paramètres dans l'appel de la fonctions.
9 of 15 11/13/25, 10:17
C1_python about:srcdoc
*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 di�é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
2.6.3 Les docstrings
Les docstrings consistent en des descriptions des fonctions, des classes ou des modules
que l'on dé�nit en utilisant """ """ dans la ligne suivant la dé�nition 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 :
10 of 15 11/13/25, 10:17
C1_python about:srcdoc
[Link]
2.6.4 Les retours multiples
Il est possible d'avoir plusieurs objets dans un return de fonctions. Dans ce cas ces
di�érents éléments sont soit stockés dans un tuple, soit associé à di�é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
2.6.5 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]
2.7 Les classes
2.7.1 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
2.7.2 Dé�nir une classe
On dé�nit simplement des classes en Python
In [68]: class MonImage:
def __init__(self, resolution = 300, source = "./", taille= 500) :
[Link] = resolution
[Link] = source
[Link] = taille
11 of 15 11/13/25, 10:17
C1_python about:srcdoc
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 �n de l'ouvrage.
2.8 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]())
2020-12-03
On donne souvent des noms courts aux packages :
In [74]: import numpy as np
In [75]: print([Link](1))
[0.67058607]
On peut aussi importer une classe ou une fonction spéci�quement :
12 of 15 11/13/25, 10:17
C1_python about:srcdoc
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]
2.9 Aller plus loin
2.9.1 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 a�ché mais le programme execute quand même ce qui se
trouve après �nally
In [81]: rapport2("&", 3)
Le calcul est terminé
13 of 15 11/13/25, 10:17
C1_python about:srcdoc
--------------------------------------------------------------------------
-
TypeError Traceback (most recent call las
t)
<ipython-input-81-f1f1fcb3db51> in <module>
----> 1 rapport2("&", 3)
<ipython-input-78-74446a11f354> 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'
2.9.2 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 [82]: 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")
Vrai
2.9.3 Les décorateurs
Il s'agit d'utiliser des fonctions de fonctions. Vous pouvez consulter l'ouvrage pour plus
de détails.
In [83]: def bonjour() :
return "Bonjour !"
def bonjour_aurevoir(fonction) :
print(fonction(), "Au revoir !", sep="\n")
bonjour_aurevoir(bonjour)
Bonjour !
Au revoir !
In [84]: # 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 :
14 of 15 11/13/25, 10:17
C1_python about:srcdoc
print("Mauvais utilisateur")
return verif_utilisateur
In [85]: # on définit un mauvais utilisateur avec le bon password
utilisateur="Paul"
password_emmanuel="Python"
In [86]: # 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 [87]: # on appelle la fonction décorée
afficher_mot_de_passe(utilisateur)
Mauvais utilisateur
In [88]: # on change d’utilisateur
utilisateur="Emmanuel"
afficher_mot_de_passe(utilisateur)
Mon mot de passe est Python
Ce chapitre ainsi que ce notebook ne constitue qu'un avant-goût de toutes les
possibilités de Python.
Dans la suite, nous allons nous intéresser plus précisément au outil pour le traitement
de données de Python.
Si vous désirez approfondir votre pratique du langage avec notamment les héritages
pour la programmation orientée objet, je vous invite à consulter le wiki de la Python
Software Foundation : [Link]
Et les nombreuses ressources web (notamment [Link]
De nombreuses autres ressources vous permettrons de compléter vos compétences en
Python
In [ ]:
15 of 15 11/13/25, 10:17