Blog

Machine Learnia > Blog > Regression > Apprendre Python en 9 vidéos

Apprendre Python en 9 vidéos

3 septembre 2019
Publié par : Sylvain
Catégorie : Regression

Cet article est une introduction au langage python, spécialement pour la pratique du Machine Learning. Nous allons voir Les bases du langage Python, avec les listes, les tuples, les fonctions principales.

Installer Python sur mon ordinateur

Pour télécharger Anaconda depuis le site officiel, cliquez ici. Pensez bien à sélectionner la version compatible avec votre système d’exploitation (Windows, Mac, Linux) ainsi que la version la plus récente de Python (Python 3).

Le navigateur Anaconda ne présente qu’un onglet important, c’est l’onglet Environnement qui vous permet de très simplement ajouter ou retirer des packages (c’est-à-dire des fonctionnalités)

Pour écrire un programme avec Python, il existe plusieurs éditeurs de texte:

Jupyter Notebook: Parfait pour analyser des données et visualiser rapidement les résultats de modèles de machine learning.
Spyder: Préférable pour développer des programmes plus longs et plus complexes.
VScode: Pour les projets mêlants plusieurs technologies différentes
Pycharm: Pour toute utilisation de python (Machine Learning, Web, Algorithmique, Visualisation, …)

Python : Variables et Fonctions

Cliquez ici pour voir la vidéo Youtube de ce chapitre

A la base de tout programme scientifique, on trouve des variables et des fonctions. Par exemple, on peut définir une variable “v” et “d” qui désignent respectivement la vitesse d’une voiture (en km/h) et la distance de trajet(en km) pour ensuite calculer le temps de trajet “t”. Pour cela, on définit une fonction $Temps(v, d) = \displaystyle \frac{d}{v}$

En python, cela donnerait le code suivant

def Temps(v, d):  
    return d/v

Variables

On peut créer des variables de plusieurs types différents.

Nombres entiers: int
Décimales: float
Chaîne de caractère: string
Boolean: bool
et pleins d’autres types que nous verrons plus loin dans cet article : Listes, dictionnaires, etc.

Pour afficher des variables, ou n’importe quel autre information, on utilise la fonction print()

# ceci est un commentaire
'''
ceci est un commentaire
sur plusieurs lignes
'''

x = 1 # type int
y = 3.14 # type float
prenom = 'Julien' # variable de type string

print(prenom)

Bien sur, il est possible de faire des opérations arithmétiques sur des variables numériques, ainsi que des comparaisons. Le résultats des comparaisons est un boolean. Pour finir, on peut faire des opérations logiques entre plusieurs boolean.

Note: Si vous n’êtes pas familier avec ces opérations, ne vous en faites pas ce n’est pas ce qu’il y a de plus important (mais voici un article Wikipédia qui vous résume le principe)

# Arithmétique
print(x + y)
print(x - y)
print(x * y)
print(x / y)
print(x // y) # division entière
print(x ** y) # x puissance y

# Comparaison -> True / False
print(x == y) # x égal y
print(x != y) # x pas égal y
print(x <= y) # x inférieur ou égal a y
print(x > y) # x strictement supérieur a y

# Logique (moins important a savoir)
print(x & y) # fonction AND
print(x | y) # fonction OR
print(x ^ y) # fonction XOR

Fonctions

Pour faire des simples mathématiques, on peut créer des fonctions mathématiques anonyme en utilisant la commande lambda. En principe, on ne donne pas de nom à ces fonctions (mais ici je l’ai nommé f).

f = lambda x: x**2 # équivaut a créer une fonction f(x) = x^2

# utilisation de la fonction f
print(f(4)) # résultat = 16

Mais le plus souvent on définit des fonctions plus complexes en utilisant la méthode def. Quand on crée une fonction, il est important de bien documenter son code (par l’ajout de commentaires) pour expliquer le but et le fonctionnement de la fonction.

def energie_potentielle(m, h, g=9.81):
    ''' energie_potentielle(m, h, g)
    fonction qui calcul et affiche l'Energie potentielle d'un corps de masse m (en kg)
    situé a une hauteur h (en m). la constante de pesanteur g=9.81 pour la Terre '''

    E = m*g*h
    print(E, 'Joules') # imprime E, en indiquand l'unité Joules 
    return E


# utilisation de la fonction
resultat = energie_potentielle(m=5, h=10)

A l’entrée d’une fonction, on a des attributs (ce sont les inputs). Ces attributs sont désignés par des keywords (le nom des attributs). Les attributs peuvent prendre des valeurs par défaut.
A l’intérieur de la fonction, certaines variables peuvent être créées, on parle alors de variable locale (qui n’existe qu’à l’intérieur de la fonction).
Pour finir la fonction produit en sortie ce qui est indiqué par la ligne return. Cette sortie doit être enregistrée dans une variable lors de l’utilisation de la fonction (ici la variable résultat).

Écrire des algorithmes avec Python

Pour créer des algorithmes, on utilise 3 structures de contrôle dans le monde de la programmation:

les alternatives IF/ELSE
les boucles FOR
les boucles WHILE

Alternatives IF/ELSE

C’est la base de la plupart des algorithmes. Le IF/ELSE permet d’exécuter des actions uniquement si une condition est vérifiée. Pour être plus précis, l’action n’est exécutée que si le résultat de la condition est True. On peut ainsi mêler booleans et opérations logiques. Si le résultat n’est pas True, alors la condition suivante est testée (Elif) et ainsi de suite jusqu’à atteindre le Else.

x = -2
if x > 0 :
    print(x, 'est positif')
elif x < 0:
    print(x, 'est negatif')
else:
    print(x, 'est nul')

Application typique: Si le capteur arrière de la voiture aperçoit un obstacle trop proche, freiner, sinon, continuer de reculer.

Boucle FOR

La boucle FOR permet d’effectuer des actions sur tous les éléments d’une séquence. La séquence la plus simple qui existe est la séquence range(). Par exemple range(10) produit la séquence 0, 1, 2, 3, 4, 5, 6, 7, 8, 9.

for i in range(10):
    print(i, i**2) # imprime la valeur de i, puis i**2

Application typique: Pour tous les fichiers d’un dossier, effectuer les actions suivante: ouvrir le fichier, le modifier, puis le fermer.

Boucle WHILE

La boucle WHILE permet d’exécuter des actions aussi longtemps qu’une certaine condition est respectée (True). C’est un peu comme si la boucle IF se répétait aussi longtemps qu’elle donne True.

i = 0
while i < 10:
    print(i**2)
    i += 1 # Sans cette ligne, l'algorithme s'execute sans fin ! car i resterait toujours < 10 !

Application typique: Pour une machine qui tourne 24h/24h: Tant que le bouton “d’arrêt d’urgence” n’est pas enclenché, continuer le travail.

Manipuler des données avec les Structures de données

Contrairement à une variable $x=1$ qui ne stocke qu’une valeur (ici 1), les Structures de données permettent de ranger pleins de valeurs sous un même nom. Dans Python, les Listes, les Tuples et les Dictionnaires sont les structures de bases qu’il est important de connaitre. (Il existe également les Sets, mais ils sont moins utilisés)

Les Séquences: Listes et Tuple

Les Listes et les Tuples sont des structures de données hétérogènes (on peut y placer plusieurs types de valeurs : int, string, etc.) Et forment ce qu’on appelle des Séquences

Différence entre Liste et Tuple ?
Une liste peut être mutée (on peut y rajouter / enlever des valeurs) tandis qu’un Tuple ne peut pas l’être. Les Listes sont plus souvent utilisées que les Tuples, mais Les Tuples ont quand même l’avantage d’être plus rapide pour la machine.

Qu’est-ce-qu’une Séquence ? Indexing et Slicing

Dans une séquence, les éléments sont rangés dans un ordre bien précis. On dit que les éléments sont indexés. On peut ainsi accéder à chaque élément en indiquant sont index. Cette technique s’appelle l’indexing, et permet d’afficher des éléments, ou bien de les modifier.

# Création d'une liste de villes
villes = ['Paris', 'Berlin', 'Londres', 'Bruxelles']

print(villes[0]) # affiche Paris
print(villes[-1]) # affiche le dernier élément de la liste


# Remplace Berlin par Montreal ! Vive le Québec :)
villes[1] = 'Montreal'

print(villes) # affiche la liste complete.

Le Slicing est une autre technique importante à connaitre : elle permet d’accéder à une “fourchette” de valeurs de notre liste, créant ainsi une mini-séquence. Pour ça, on indique un index de début et un index de fin.

# affiche les valeurs en partant de l'index 1 jusqu’à atteindre l'index 3
print(villes[1:3])

Actions sur une Liste

On peut effectuer beaucoup d’actions sur une Liste, par exemple:

La trier (alphabétiquement ou numériquement selon le cas)
En mesurer la longueur
Compter combien de fois un même élément apparaît
insérer un ou plusieurs éléments,
etc.

Toutes ses actions sont disponibles à travers l’utilisation de méthodes (nous reverrons ce terme à la fin de cette formation, dans la programmation orientée objet)

# Création d'une liste de villes
villes = ['Paris', 'Berlin', 'Londres', 'Bruxelles']

villes.append('Madrid') # ajoute 'Madrid' a la fin de la liste
print(villes)

villes.extend(['Dublin', 'Geneve']) # ajoute une liste a la fin de la liste villes
print(villes)

villes.insert(3, 'Paris') # insert 'Paris' au troisieme index de la liste, décallant ainsi le reste de la liste)
print(villes)

print(villes.count('Paris')) # affiche le nombre de fois que 'Paris' apparait dans la liste

print(len(villes)) # affiche la longueur de la liste (len() est une fonction, pas une méthode)

villes.sort(reverse=False) # trie la liste villes
print(villes)

Note: Les Tuples n’ont pas toutes ces méthodes à disposition, car ils sont non-mutables, rappelez-vous ! 🙂

Les Séquences dans les boucles FOR et les IF/ELSE

Les Séquences telles que les Listes et les Tuples fonctionnent en parfaite combinaison avec les boucles FOR et les alternatives IF/ELSE. Le code suivant parle de lui-même

# Création d'une liste de villes
villes = ['Paris', 'Berlin', 'Londres', 'Bruxelles']

# ==========================================================================
# BOUCLE FOR
# ==========================================================================
for i in villes:
    print(i)


# ==========================================================================
# IF/ELSE
# ==========================================================================
# testons si la ville suivante est dans la liste villes
ville_test = 'Belfast'

if ville_test in villes:
    print(ville_test, 'présente dans villes')
else:
    print(ville_test, 'absente de villes')

En bonus, voici une petite fiche résumé que vous pouvez imprimer !

Avant de passer aux dictionnaires, voici une fiche résumé qui vous indique ce que vous devez vraiment retenir.

Structure associative: Le Dictionnaire

Le Dictionnaire est une autre structure de données importante à connaitre. Il sert notamment de base à Pandas, le package le plus important des Data Scientists.

Qu’est-ce-qu’un Dictionnaire ?

Un Dictionnaire n’est pas une séquence: il n’y a pas d’ordre dans ses éléments. A la place, un Dictionnaire est un regroupement d’associations entre des clefs et des valeurs. C’est un peu comme si vous aviez plusieurs variables et que vous vouliez toutes les mettre dans un même panier (le dictionnaire), mais au lieu d’appeler ça des variables, on appelle ça des clefs.
Une clef est unique, elle ne peut pas exister en deux exemplaires.
Voici comment créer un dictionnaire:

'''Création d'un dictionnaire "inventaire"
les clefs sont les fruits
les valeurs sont les quantités '''

inventaire = {
        "bananes": 100,
        "pommes": 250,
        "poires": 175,
        "cerises": 300
        }

print(inventaire) # affiche le dictionnaire

print(inventaire.keys()) # affiche les clefs du dictionnaire

print(inventaire.values()) # affiche les valeurs du dictionnaire

print(inventaire.items()) # affiche les associations clef : valeur

Note: Les dictionnaires ne disposant pas d’ordre (d’index) il n’existe pas de méthode append() insert() ou extend(). Celles-ci n’ont simplement pas d’intérêt. On accède aux valeurs en indiquant la clef que l’on désire, comme ci-dessous.

print(inventaire['bananes']) # affiche la valeur associée a 'bananes'

inventaire['bananes'] = 350 # change la valeur associée a 'bananes'

inventaire['abricots'] = 225 # voici comment créer une nouvelle association

Quelques méthodes sur les Dictionnaires

Dans la vidéo du dessus, je présente certaines méthodes intéressantes sur les Dictionnaires, comme les méthodes get(), pop() et fromkeys(). Je vous laisse les découvrir en vidéo et à travers le code suivant:

inventaire = {
        "bananes": 100,
        "pommes": 250,
        "poires": 175,
        "cerises": 300
        }

# ===============================================================
# METHODE GET
# ===============================================================
print(inventaire.get('poires')) # retourne la valeur associé a la clef
print(inventaire.get('peches', 0)) # si la clef n’existe pas, retourne une valeur par défaut

# ===============================================================
# METHODE POP
# ===============================================================
valeur = inventaire.pop('cerises') # extrait une association du dictionnaire
print(valeur) # la valeur de l'association
print(inventaire) # le dictionnaire ne contient plus cette association

# ===============================================================
# METHODE FROMKEYS
# ===============================================================
fruits = ['peches', 'oranges', 'kiwi'] # une liste de fruits
inventaire = dict.fromkeys(fruits, 100) # créer un dictionnaire a partir de la liste de fruit, en assignant une valeur par défaut
print(inventaire)

Un exemple d’application

Application typique: Dans une boucle FOR, vous voulez enregistrer un résultat dans un nouvelle variable pour chaque itération de la boucle. Le problème, c’est que dans la plupart des langages de programmation, il est impossible de créer une variable dans une boucle FOR ou WHILE. En revanche, il est possible de créer de nouvelles clefs dans un dictionnaire dans une boucle FOR ou WHILE. Cela rend le dictionnaire très utile.

dictionnaire = {} # création d'un dictionnaire vide

for i in range(10):
    dictionnaire[i] = i**2 # association de la clef i a la valeur i**2

print(dictionnaire)

Liste Compréhension: une technique plus avancée mais très utile

La Liste compréhension n’est rien d’autre qu’une technique pour créer une Liste de façon plus simple, plus professionnelle, et plus performante. Ces 3 points suffisent pour affirmer que cette technique est importante, et elle fait parfois l’objet de questions en entretien d’embauche !

Cela consiste à créer une liste en écrivant sur une même ligne:

La Liste
une boucle for
avec optionnellement une condition

# ===============================================
# MÉTHODE CLASSIQUE
# ===============================================

liste_1 = [] # création liste vide
for i in range(10):
    if i%3 == 0: # si i est multiple de 3
        liste_1.append(i**2) # ajoute i**2 a la liste

print(liste_1)
        
# ===============================================
# LISTE COMPREHENSION
# ===============================================

liste_2 = [i**2 for i in range(10) if i%3==0]

print(liste_2)

Les Built-in Functions de Python

Python comprends nombre de fonctions déjà implémentées pour vous aider dans votre travail. Ces fonctions sont TRÈS UTILES ! Pour preuve, parmi elles, ont trouve les fonctions print(), len(), zip() et enumerate(). Eh bien si je vous disais qu’il en existe pleins d’autres comme ça, vous me croiriez ?

Ces fonctions sont toutes documentées ici, sur le site officiel de python. Dans la vidéo ci-dessus je vous présente les plus utiles, à savoir:

Les basiques: abs(), sum(), max(), min(), len(), all(), any()
les conversions: int(), float(), str(), list(), tuple(), dict()
input()
format()
open()

Fonctions basiques

x = -2
print('valeur absolue', abs(x))

x = 3.14
print('arrondi', round(x))


liste_1 = [0, 23, 14, -19]
print('max', max(liste_1))
print('min', min(liste_1))
print('longueur', len(liste_1))
print('somme', sum(liste_1))

Fonctions de conversion

x = 10 # type int
print(type(x)) # affiche le type. cette fonction est tres utile !

x = str(x) # convertit x en string
print(type(x)) # re-affiche le type

y = '20' # type string
y = int(y) # convertit y en int
print(type(x)) # affiche le type de y

liste_1 = [0, 61, 63, 243]
tuple_1 = tuple(liste_1) #convertit la liste en tuple
print(type(tuple_1))

print(type(list(tuple_1))) # convertit un tuple en liste.

Format(): intégrez des valeurs dans vos strings

La fonction format() permet tout simplement d’intégrer des valeurs dans des chaines de caractère. Voici comment procéder:

x = 30
y = 24
print('j'ai {} ans, et toi {}'.format(x, y))
print(f'j'ai {x} ans, et toi {y}') # une autre facon, plus rapide.

Open(): Ouvrez n’importe quel fichier de votre ordinateur

La fonction open() est très importante pour ouvrir et lire des documents sur votre machine, ou bien écrire un document et l’enregistrer sur votre machine !

Cette fonction crée un objet fichier f sur lequel on peut utiliser des méthodes pour effectuer des actions comme:

f.write() pour écrire dans le fichier (en écrasant son contenu)
f.read() pour lire le fichier
f.apprend() pour écrire depuis la fin du fichier (n’écrase pas le contenu)

Une fois les opérations terminées, il faut penser à fermer le fichier avec f.close().

Pour plus de performance, on peut utiliser la commande with, qui ne crée pas de référence au fichier f dans la mémoire de l’ordinateur. Dans ce cas, vous n’avez pas besoin de fermer le fichier.

# Crée un fichier pour écrire dedans (mode 'w')
f = open('fichier.txt', 'w') 
f.write('bonjour') # écrit le message "bonjour"
f.close() # ferme le fichier. le fichier existe désormais sur votre machine.


# ouvre le fichier qui vient d’être créé (mode 'r')

f = open('fichier.txt', 'r')
print(f.read()) # affiche le contenu du fichier
f.close() # ferme le fichier


# en utilisant la commande with + un petit jeu avec la fonction format()
with open('fichier.txt', 'w') as f:
    for i in range(10):
        f.write("{}^2 = {} \n".format(i, i**2))

Les modules les plus utiles de Python

Dans python, chaque programme que vous écrivez porte le nom de module. C’est un fichier qui regroupe différentes fonctions et variables. Il est possible d’importer vos modules dans d’autres programmes que vous pourriez écrire, afin de bénéficier des fonctions que vous auriez déjà développer.

Mais ce qui est encore plus intéressant, c’est d’importer des modules qui ont déjà été développer pour vous. Par exemple des modules qui permettent de faire des mathématiques ou bien des statistiques facilement ! Tous ces modules sont documentés ici, sur le site officiel de Python. Comme vous pouvez le constater, il y en a BEAUCOUP, je dirais même beaucoup trop ! C’est pour cette raison que je vais guider dans les modules les plus importants:

math
statistics
random
glob

Différence entre Module et Package ?
Un package est un regroupement de modules. Par exemple Numpy est un Package, mais beaucoup de gens disent que c’est un module par abus de langage (rien de grave, et je le fais moi-même sans m’en rendre compte).

Les basiques : math et statistics

import math
import statistics

print(math.pi) # nombre pi
print(math.cos(2*math.pi)) #cos(2*pi)

# Création d'une liste
nombres = [3, 5, 1, 0, 2]

print(statistics.mean(nombres)) # moyenne
print(statistics.variance(nombres)) # variance
print(statistics.stdev(nombres)) # écart type

Random: le module des nombres aléatoires

Le module random est l’un des plus utile de Python: voici une liste non-exhaustive des actions que vous pouvez faire avec ce module:

Générer des nombres aléatoires
Générer des listes remplies de nombres aléatoires
Mélanger une Liste aléatoirement
Choisir au hasard un élément dans une Liste

Astuce: Pour avoir un certain contrôle sur le hasard, vous pouvez fixer le générateur de nombres aléatoires random.seed() pour qu’il produise toujours le même résultat ! C’est très utile !

import random

random.seed(0) # fixe la RNG au reglage 0

print(random.random()) # Crée un nombre float
print(random.randint(0, 10)) # Crée un nombre entier (entre 0 et 10)


# Génére une liste aléatoire de longueur 5
liste_aleatoire = random.sample(range(100), 5)
print(liste_aleatoire) #affiche la liste


# Choisit un élément aléatoire de la liste
print(random.choice(liste_aleatoire)) 

# Mélange la liste au hasard 
random.shuffle(liste_aleatoire)
print(liste_aleatoire)

Glob: Accédez aux fichiers de votre ordinateurs

La fonction glob.glob() est formidable ! Elle retourne une liste de tous les fichiers présents dans votre répertoire de travail (ou de tout autre répertoire de votre ordinateur). Avec cette liste, on peut utiliser la fonction open() dans une boucle FOR, ce qui permet d’ouvrir tous les fichiers présents dans un répertoire et d’effectuer des actions sur ces fichiers.

import glob

filenames = glob.glob("*.txt") # liste tous les fichiers avec l'extension .txt

for file in filnames(): # selectionne l'un apres l'autres les fichiers dans filenames
    with open(file, 'r') as f: # ouvre le fichier
        print(f.read()) # affiche a l'écran le contenu du fichier