Introduction au Python - Vidéo
Introduction au Python - Résumé
Le code est une série d’instructions qu’on demande à la machine d’exécuter dans une certaine langue. Pour que cette langue soit comprise, il faut que l’interpréteur de cette langue soit installé sur l’ordinateur.
Le Python est un langage de programmation facile, flexible et largement utilisé dans toutes les applications liées à la data. Pour écrire du python, on écrit le code dans un IDE, c’est-à-dire dans un environnement d’édition de texte pensé pour.
Pour les analyses, spécifiquement, on préférera utiliser des jupyter notebooks qui offrent un format permettant à la fois d’écrire et exécuter du code directement depuis le navigateur web mais également afficher les résultats et écrire des commentaires.
Les variables sont des objets contenant une valeur. On leur donne le nom que l’on souhaite. Une valeur peut-être de plusieurs types différents: int (pour les entiers), float (pour les chiffres à virgules), str (pour le texte).
Une variable peut contenir aussi plusieurs valeurs et on parlera à ce moment-là de collection de valeurs. Il en existe de 3 types différents en Python:
- list : C’est une collection de valeurs, pouvant être de types différents, ordonnée. Elle est représentée entre crochets. Par exemple [1, 8,10]. Pour accéder à un élément, on le fera par son indice (les indices commencent à 0).
- dict : C’est une collection de clefs / valeurs, pouvant être de types différents et de façon non ordonnée. Elle est représentée entre accolades. Par exemple {“A”: 3, “B”: 6}. Pour accéder à un élément, on le fera par le nom de sa clef.
- tupl : Elle est équivalente à la liste dans sa structure mais aucun de ses éléments ne peut être modifié. Elle est représentée par des parenthèses. Par exemple (“Paul”, “Mochkovitch”, “1990-08-13”).
Pour distinguer des cas de figure, il est utile d’utiliser des conditions. En python, elles s’écrivent:
if(condition):
bloc_instruction_1
elif(other_condition):
bloc_instruction_2
else:
bloc_instruction_3
Une condition est soit vraie ou fausse (ou bien 1 ou 0). Elle utilise pour cela des opérateurs de comparaisons: >, >=, <, <=, ==, !=, in, not in. Elle peut-être composée de plusieurs sous conditions, on utilisera alors les opérateurs logiques and / or.
Une boucle permet quant à elle de répéter une série d’instructions. Il existe deux types de boucles, FOR et WHILE. Le FOR répète autant de fois qu’il y a d’éléments dans l’objet à parcourir. Le WHILE répète autant de fois que nécessaire, jusqu’à ce que sa condition devienne fausse. Elles s’écrivent:
while(condition):
bloc_instruction_to_repeat
for i in my_object:
bloc_instruction_to_repeat
On regroupe généralement les instructions ayant un même but ensemble dans ce qu’on appelle une fonction. A l’appel de cette fonction, les instructions qui lui sont liées seront exécutées. Ces instructions peuvent prendre des paramètres en entrée. Une fonction ne retourne rien si on n’utilise pas l’opérateur return à la fin. Les fonctions s’écrivent:
def my_function(parameter_1, parameter_2):
bloc_instruction_to_execute
return return_value
Introduction au Python - Cours écrit
Pourquoi Python ?
Python a été créé en 1990 par Guido van Rossum dans le but de permettre aux utilisateurs d’écrire du code simplement, efficacement et de façon très lisible. Encore aujourd’hui, il est considéré comme un langage de programmation “facile” de par sa facilité de lecture. Mais cet atout n’enlève en rien à son efficacité. Il est le langage le plus utilisé pour l’analyse de données et toutes ses applications comme le développement de l’intelligence artificielle par exemple. C'est le langage officiel pour pratiquer le deep learning chez Google et Facebook. Ayant par ailleurs une communauté très active, le python ne s’est pas cantonné à simplement l’analyse de données mais compte aujourd’hui parmi les langages les plus complets. En effet, grâce au travail mutuel des utilisateurs mis en open source, on peut aujourd’hui l’utiliser pour à peu près tout, comme créer des applications, se connecter à n’importe quelle base de données... C’est aujourd’hui la langue la plus apprise et la plus demandée sur le marché du travail en analyse de données.
Néanmoins, Python a quelques défauts. On lui reproche, entre autres, de ne pas être très rapide dans son exécution (mais rassurez-vous on parle de petites différences). Mais la plupart des outils que nous allons utiliser reposent, en vrai, sur un mélange de Python et de C, qu’on appelle le Cython. Il vise à réduire cette différence de performance. Il existe plusieurs versions de Python, mais la seule aujourd’hui maintenue est Python 3. Ne perdez pas votre temps à lire des choses sur la version 2. On parle actuellement d’une version 4 mais prévue dans longtemps.
Dans le cours d’aujourd’hui, nous allons apprendre ensemble les bases du langage mais pas encore son utilisation pour l’analyse de données. Néanmoins, il est très important de bien comprendre ces notions car elles sont utilisées partout et vous aideront à mieux appréhender la suite !
Les outils pour écrire du Python
Pour écrire du code, on utilise généralement un IDE qui joue le rôle d’un éditeur de texte spécifique. Il offre des features intéressantes comme la détection d’erreurs avant même l’exécution, la documentation directement intégrée ou encore l’auto-complétion du code. En python, il existe trois IDE très connus:
Pour l’analyse de données, une nouvelle façon d’écrire du code est apparue via l’utilisation de Jupyter Notebooks. La différence est que directement dans le navigateur web, vous pouvez écrire et exécuter du code sans devoir exécuter tout d’un coup. Par ailleurs, vous avez la possibilité d’écrire du texte, d’afficher des photos / vidéos et d’afficher des graphiques. C’est donc un format remarquable pour la restitution d’analyses. Néanmoins, gardez bien en tête que ce format n’est que pour l’analyse et en rien pour le développement d’application ou pour la création d’un nouveau produit.
Pour éviter tout problème d’installation possible sur votre ordinateur, nous utiliserons les Jupyter Notebooks via l’outil mis à disposition par Google et de façon gratuite: Google Colaboratory. Cette interface exécutera vos lignes d’instructions Python non pas sur votre ordinateur mais bien sur un ordinateur dans le cloud avec une ressource de calcul bien plus importante. C’est assez fantastique ! Vous êtes maintenant prêts à faire connaissance avec Python.
Mais si vous souhaitez installer Python sur votre ordinateur, on vous guide pas à pas dans cet article !
Les variables et types
Tout d’abord comme sur n’importe quelle calculette, nous pouvons faire des opérations arithmétiques élémentaires. La fonction print permet d’afficher un résultat. Il suffira de lui indiquer entre parenthèses le résultat à afficher. Prenons l’exemple suivant:
print(3 + 4)
Cette instruction renvoie le résultat 7. Pour pouvoir réutiliser des résultats intermédiaires, on a besoin d’introduire des variables. Les variables sont des objets qui contiennent des valeurs. Le nom d’une variable ne doit pas contenir d’espace et ne doit pas commencer par un chiffre. En reprenant l’exemple précédent, on pourrait décider de stocker le résultat de l’opération 3 + 4 dans une variable pour ensuite l’afficher:
result = 3 + 4
print(result)
Ici on a choisi result comme nom de variable. La première ligne va calculer 3 + 4 donc 7 puis va l’insérer dans la variable result. C’est ce qu’on appelle une affectation et elle est indiquée par le simple signe =. L’instruction suivante va afficher la valeur contenue dans result, à savoir 7.
Plus précisément, une variable est une adresse mémoire de l’ordinateur qui contient la valeur qu’on lui affecte. On fait référence à cette adresse mémoire par le nom choisi pour la variable. Par ailleurs, deux variables ne peuvent pas avoir le même nom, c’est un peu leurs numéros de sécurité sociale si vous voulez.
On peut changer la valeur d’une variable en changeant simplement la valeur à son adresse mémoire. Pour cela, rien de plus facile, il suffit de faire une nouvelle affectation :
result = 3 + 4
result = 12
print(result)
La première ligne affecte 7 à la variable result. La seconde affecte 12 à la variable result, remplaçant donc la valeur précédente. La troisième et dernière ligne affiche la valeur de result donc 12.
On peut également réutiliser la valeur précédente de la variable. Par exemple, si nous souhaitons multiplier par 2 la valeur de result, nous pourrions écrire:
result = 3 + 4
result = result * 2
print(result)
La troisième instruction affichera 14, car result vaut 7 à la première ligne et est multipliée par 2 à la seconde.
Comme en SQL, il existe plusieurs types de données que peut contenir une variable:
- int: désigne les entiers positifs ou négatifs
- float: désigne tous les chiffres à virgules positifs ou négatifs
- str: désigne du texte (toujours représenté entre guillemets)
La fonction type() est très utile, car elle permet de savoir le type d’une variable:
result = 3.23
print(type(result))
result = -8
print(type(result))
Result = "my first sentence in python"
print(type(result))
Cette suite d’instructions utilise trois fois la fonction print donc va afficher trois fois un résultat, en l'occurrence le type de la variable result. Le premier print va renvoyer float car la valeur de result est un chiffre à virgule (3.23), le second int car -8 est un chiffre entier et enfin le troisième renverra str car “my first sentence in python" est bien du texte. A travers cet exemple, on observe qu’on peut changer la valeur d’une variable par ce qu’on veut même si ce n’est pas du même type. Pour votre information, ce n’est pas du tout le cas de tous les langages et en particulier pour ceux qui sont dits “typés”. En effet, pour ces derniers, vous devez associer un type à votre variable et vous y tenir. Le Python a ce qu’on appelle un typage dynamique, car le type d’une variable peut être changé à tout moment.
Les variables peuvent aussi contenir non pas qu’une seule valeur, mais une collection de valeurs, on parlera alors de structure de données.
Les différentes structures de données
Il est très souvent utile de vouloir insérer dans une variable pas une mais plusieurs valeurs comme les informations du nom et du prénom d’une personne par exemple. Il existe 3 sortes de structures de données en Python:
List
Une liste est une collection d’objets de types identiques ou différents de façon ordonnée. Elle est représentée en Python par des crochets [ ] et a un type list. Chaque objet dans la liste est séparé par une virgule. Imaginons, que nous souhaitions créer une variable my_list contenant une liste d’entiers 1, 2, 3, on écrira:
my_list = [1, 2, 3]
On peut aussi bien mélanger les types dans la liste, comme cela:
my_list2 = [1, "arbre", 3]
Remarquez que l’ordre importe ici ! Dans la première liste le chiffre 2 de type int est entre les chiffres 1 et 3. Dans la seconde, les types ne sont pas identiques, le premier et le troisième élément sont de types int alors que le second est du texte donc de type str.
Pour accéder à un élément de la liste, on peut y faire référence par rapport à son indice. En Python les éléments sont numérotés à partir de 0:
print(my_list[0]) # 1
print(my_list2[1]) # "arbre"
Les # représentent en python des commentaires, ils sont ignorés quand le code est interprété. Dans la première ligne d’instruction, on cherche à afficher l’élément d’indice 0 de la liste my_list, c’est à dire le premier élément donc 1. De même, pour la seconde, l’instruction affichera le deuxième élément de la liste my_list2, c’est-à-dire “arbre”. Remarquez bien l’utilisation des crochets pour accéder à un élément. Il est également possible de sélectionner plusieurs éléments d’une liste en utilisant le principe de slicing. Vous précisez entre les crochets l’indice de départ, suivi de : et enfin l’indice de fin. Cela va sélectionner tous les éléments de la liste ayant un indice compris entre celui de départ et celui de fin exclu. Pour sélectionner les deux premiers éléments de my_list2, on écrira donc:
my_list2[0:2] # [1, "arbre"]
Cette instruction renverra donc une liste constituée des premiers éléments.
Pour modifier une valeur, il suffit d’écraser la valeur à l’indice souhaité. Par exemple, si on veut que le troisième élément de my_list2 soit “fleur”, on fera:
my_list2[2] = "fleur" # remplace l'élément d'indice 2 par "fleur"
print(my_list2) # display [1, "arbre", "fleur"]
Les listes viennent avec leurs propres fonctions pour leur gestion. Voici une liste non exhaustive des fonctions disponibles:
- La fonction len() retourne la taille de la liste
- La fonction .append() ajoute l’élément entre parenthèse en dernière position de la liste
- La fonction .pop(indice): supprime l’élément ayant l’indice passé en paramètre. Sans cet indice passé, cette fonction supprime le dernier élément par défaut.
Créons un exemple utilisant toutes ces fonctions:
my_list = [1, 3, 8]
my_list.pop(1) # delete element with index 1 which is 3
print(my_list) # [1,8]
my_list.append(4) # add object 4 at the end
print(my_list) # [1, 8, 4]
print(len(my_list)) # 3
Dict
Un dictionnaire est également une collection d'objets mais n’est pas ordonné. Il fonctionne avec le principe de clef / valeur. A une clef donnée du dictionnaire, une valeur y est associée. La clef comme sa valeur peuvent être de plusieurs types différents. Cette structure a un type dict et est représentée par des accolades { }. Prenons un exemple d’un dictionnaire qui a deux clefs “A” et “B” ayant comme valeurs respectives les entiers 1 et 2. Nous allons créer une variable contenant ces informations sous forme de dictionnaire:
my_dict = {"A": 1, "B": 2}
Chaque clef / valeur est séparée par une virgule. La clef est toujours à gauche des “:” et la valeur à droite. Chaque clef dans un dictionnaire est unique ! Pour accéder à la valeur d’une clef, on ne peut plus le faire par indice car cette notion n’existe pas, mais simplement par son nom. Vous pouvez accéder aussi rapidement à toutes les clefs. On utilisera des [ ], comme dans les listes, pour accéder aux valeurs:
print(my_dict["A"]) # 1
Cette instruction va afficher la valeur enregistrée dans le dictionnaire my_dict pour la clef “A”, c’est-à-dire 1. Pour modifier la valeur d’une clef existante, par exemple changer la valeur de la clef “A” par 4, on procédera ainsi:
my_dict["A"] = 4
De même que les listes, les dictionnaires viennent avec leurs propres fonctions:
- La fonction len() retourne le nombre de clefs dans le dictionnaire
- La fonction .keys() retourne la liste des clefs du dictionnaire
- La fonction .values() retourne la liste des valeurs du dictionnaire
- La fonction .pop(nom_de_la_clef) supprime du dictionnaire la clef passée entre parenthèses et sa valeur associée
Pour ajouter une nouvelle clef “C” avec une valeur associée 6 au dictionnaire, on procèdera ainsi:
my_dict["C"] = 6
Créons un exemple avec tous ces enseignements:
my_dict = {"name": "Paul", "surname": "Mochkovitch"}
print(my_dict.keys()) # {"name": "Paul", "surname": "Mochkovitch"}
my_dict["birth_date"] = "1990-08-13" # add new key "birth_date" with its value "1990-08-13"
print(len(my_dict) # return number of keys, now it is 3
my_dict.pop("name") # delete key "name" from dictionary
print(my_dict) # {"surname": "Mochkovitch", "birth_date": "1990-08-13"}
Dans ce bloc d’instruction, on définit un dictionnaire avec deux clefs et une valeur associée à chacune des clefs. On affiche ensuite le nombre de clefs de ce dictionnaire. Puis, on crée une nouvelle clef “birth_date” avec sa valeur et on supprime la clef “name” du dictionnaire. Enfin on affiche le dictionnaire résultant.
Tupl
Un tuple est une collection d’éléments, de types identiques ou différents, ordonnée par indice, comme une liste, mais aucun des éléments ne peut pas être modifié. Cette structure a un type tupl et est représentée par des parenthèses ( ). Prenons un exemple d’un tuple contenant trois informations, l’id, le prénom et le nom de famille:
my_tuple = (2341, "Paul", "Mochkovitch")
Pour accéder à un élément, par exemple le prénom, on fera exactement comme les listes, on utilisera le numéro d’indice:
print(my_tuple[1]) # "Paul"
Pourquoi vouloir créer une structure qui nous empêche de modifier une valeur ? C’est pour garantir que les informations d’un tuple sont liées. Dans notre exemple, on se prémunit du risque que l’id change mais que le prénom et le nom de famille restent les mêmes. Pour modifier une valeur, il faudra carrément écrire un nouveau tuple.
Tous les éléments de toutes les structures peuvent être de types très différents et y compris des structures de données eux-mêmes. C’est pourquoi, il n’est pas rare de tomber sur des listes de listes ou des dictionnaires de listes…
Les conditions
En programmation, il est indispensable de pouvoir distinguer des cas de figure pour appliquer des instructions différentes. Par exemple, imaginez que vous créez un programme qui renvoie l’information si un utilisateur est majeur ou non basé sur son âge, vous aurez besoin de vérifier que cette personne a plus de 18 ans ou non. “Avoir plus de 18 ans” est ici la condition. En python les conditions renvoient 1 / 0 ou Vrai / Faux, ce qui est équivalent. Tout comme en SQL, il existe plusieurs opérateurs que l'on peut utiliser dans une condition:
- > : pour supérieur strict
- >= : pour supérieur ou égal
- < : pour inférieur strict
- <= : pour inférieur ou égal
- == : pour tester l’égalité
- != : pour tester la différence
- in : pour tester si un élément est dans une liste ou si un élément est une clef d’un dictionnaire
- not in : le contraire de in
Attention à ne pas confondre le simple signe = qui correspond à l'affectation d’une valeur dans une variable et le double signe == qui teste l’égalité entre deux valeurs.
Pour écrire une condition simple, il faut utiliser if comme ci-après:
age = 17
if(age < 18):
print("under age")
On définit ici la variable age de valeur 17, puis on teste si elle est bien inférieure à 18 (notez bien que la condition est entre parenthèses). Puisque c’est le cas, on va venir exécuter les lignes décalées en-dessous à droite, c’est-à-dire on affichera “under age”. En Python, le fait de décaler à droite est indispensable, car on indique ici que ce sont les instructions qui dépendent de la condition. Si maintenant on veut compléter notre condition en voulant afficher “over 18” pour un âge supérieur à 18, on peut utiliser la condition else qui joue le rôle du “sinon”:
age = 17
if(age < 18):
print("under age")
else:
print("over 18")
Il n’y a toujours qu’un seul if et qu’un seul else dans une condition. Néanmoins, vous pouvez utiliser autant de elif, qui est la contraction du else et du if et qui joue le rôle du “sinon si”, que vous souhaitez. Par exemple:
age = 20
if(age < 18):
print("under age")
elif(age < 21):
print("under age in the US")
else:
print("over 18")
Il est impossible d’exécuter, à la fois, le code du if et d’un elif ou bien d’un if et d’un else. Vos conditions doivent être choisies de telle sorte que vous ayez bien traité tous les cas de figure que souhaitiez.
Une condition peut être composée de plusieurs sous conditions et dans ce cas là, on pourra utiliser and et or pour les combiner. Par exemple, si nous souhaitons tester qu’une personne ait moins de 25 ou plus de 65 pour bénéficier de réductions pour des titres de transport, on pourra écrire:
age = 27
if((age < 25) or (age >= 65)):
print("discounts available")
else:
print("no discount")
Le or est vrai si au moins une des sous conditions est vraie. En revanche, pour le and, il faut que toutes les sous conditions soient vraies.
Les opérations de boucles
En informatique, il y a un principe d’économie de code. Si vous répétez plusieurs fois une même série d’instructions alors il est peut-être plus efficace de l’écrire une seule fois mais de demander à l’ordinateur de la répéter autant de fois que nécessaire. C’est ce qu’on appelle une boucle, répéter une même série d’instructions plusieurs fois. Il existe deux types de boucles en python:
FOR
La boucle for va répéter une série d’instructions autant de fois qu’il y a d’éléments à parcourir dans l’objet qu’on donne après le in. Prenons l’exemple d’une boucle itérant sur un objet de type list:
for i in [1, 8, 10]:
print(i)
Ce bloc d’instruction indique à l’ordinateur “pour i dans la liste [1, 8, 10] afficher i”. La liste qui est passée dans le in contient 3 éléments donc on répétera 3 fois les instructions qui sont décalées en dessous du for, à savoir afficher i. La variable i peut avoir le nom que vous souhaitez, c’est une variable comme une autre. Le fait que l’instruction en-dessous soit décalée à droite est pour indiquer de la même manière que celle-ci appartient au for et doit donc être répétée. A chaque itération, la variable i va prendre successivement la valeur suivante dans la liste [1, 8, 10] en conservant l’ordre. Cela affichera donc les résultats suivants:
1
8
10
Si l’objet passé après le in est un dictionnaire, alors on itèrera sur ses clefs.
Une autre fonction très utilisée est la fonction range, elle permet de créer une liste d’entiers consécutifs:
range(5) # equivalent to [0, 1, 2, 3, 4]
Ce qui est très pratique pour répéter une opération n fois précisément ou simplement pour itérer sur les indices d’une liste.
On peut également vouloir répéter une série d’instructions autant de fois que nécessaire jusqu’à ce qu’une condition devienne vraie. C’est le rôle de la boucle while.
WHILE
Le while peut être traduit par “tant que”. Comme son nom l’indique, tant que la condition passée n’est pas vraie, il continuera d’exécuter les instructions en boucle. Il faut donc faire attention à ce que la condition puisse devenir vraie à un moment donné, sinon ce sera une boucle infinie et votre ordinateur restera bloqué. Prenons le même exemple que précédemment où l’on souhaite afficher les valeurs d’une liste:
l = [1, 8, 10]
i = 0
while(i < len(l)):
print(l[i])
i = i + 1
Ici on déclare la liste l et une variable i valant 0. La condition est que la valeur de i soit inférieure à 3, la longueur de l. Comme à chaque exécution du bloc indenté à droite sous le while, on affiche la valeur du ième élément de la liste et qu’on augmente de 1 la variable i, on est sûr que la condition va devenir fausse une fois que tous les éléments auront été parcourus. Et on obtiendra bien en résultat:
1
8
10
Les fonctions
Pour rendre le code le plus lisible possible, on regroupe souvent les instructions nécessaires à la réalisation d’une tâche ensemble au sein d’une fonction. On donne souvent un nom explicite à la fonction pour faciliter son utilisation par les autres membres de l’équipe.
Prenons l’exemple d’une fonction qui affiche simplement “hello”:
def print_hello():
print("hello")
Pour déclarer une fonction, on commence toujours par écrire def suivi du nom qu’on souhaite donner à notre fonction. Ne pas oublier les parenthèses pour bien indiquer que vous parlez bien d’une fonction. Puis en-dessous, indentée à droite, vous mettez les instructions que vous souhaitez que la fonction exécute, donc ici simplement afficher “hello”.
Pour appeler la fonction nouvellement créée, il suffira d’écrire:
print_hello()
Notre fonction pourrait être améliorée, et ne pas simplement afficher hello mais plutôt hello avec le prénom de la personne. Pour cela, il faut introduire la notion de paramètres d’une fonction.
Un paramètre est une variable passée en entrée de la fonction pour que celle-ci puisse être utilisée dans le bloc d’instructions à exécuter. On va donc reprendre notre fonction mais en ajoutant un paramètre first_name:
def print_hello(first_name):
print("hello ", first_name)
Remarquez bien que les paramètres de la fonction doivent être insérés entre les parenthèses juste après le nom de la fonction choisie. S’il y a plusieurs paramètres à passer alors il faudra les séparer par une virgule.
Ici, le paramètre first_name va être employé dans la fonction print pour venir afficher sa valeur après le “hello “. Pour maintenant appeler la fonction, il faudra faire:
print_hello("Paul") # “hello Paul”
Une fonction ne renvoie rien par défaut, elle ne fait qu’exécuter les instructions qu’on lui a données. Si, en revanche, on souhaite récupérer un résultat en sortie, il faudra alors utiliser le code return. On indiquera à la fonction, via ce nom, que l’on souhaite retourner la variable, après le return, en sortie. Reprenons notre fonction, mais cette fois-ci, nous n’afficherons pas hello et le prénom mais nous le retournerons:
def print_hello(first_name):
sentence = "hello " + first_name
return sentence
Dans ce bout de code, on définit la variable sentence comme la concaténation de “hello “ et le paramètre first_name par l’opérateur +, puis la dernière ligne renvoie le résultat.
Pour récupérer le résultat en sortie de cette fonction, on utilisera:
my_sentence = print_hello("Paul")
print(my_sentence) # "hello Paul"
La variable my_sentence reçoit comme valeur ce que la fonction print_hello a retourné, à savoir “hello Paul”. La deuxième instruction vient juste afficher la valeur de my_sentence.
.png)