A​PPRENTISSAGE​ ​AVEC​ P​YTHON​ ​ET​ ​SICKIT​ ​LEARN

Ce document propose une introduction pratique au langage Python, destinée aux étudiants en Master 1 Business Analytics & Data Science. Il couvre les bases essentielles de Python, l’utilisation des environnements virtuels, les principales structures de données, les contrôles de flux, ainsi que quelques fonctionnalités avancées utiles pour la manipulation de données.

L’environnement Python

Utilisation des environnements virtuels

Pour travailler avec Python, il est recommandé d’utiliser un environnement virtuel afin d’isoler les dépendances. Après avoir installé le paquet python3-virtualenv, on crée un environnement nommé apprentissageArtificiel avec la commande :

python3 -m virtualenv ~/apprentissageArtificiel
source ~/apprentissageArtificiel/bin/activate

Pour quitter l’environnement, il suffit de taper :

deactivate

Les librairies

Python dispose d’un grand nombre de librairies. Leur installation se fait via le gestionnaire de paquets pip. Il est important d’activer l’environnement virtuel avant d’installer les paquets pour éviter les conflits.

Commandes principales :

• pip search <paquet> : chercher un paquet ou vérifier s’il est à jour.
• pip install <paquet> : installer un paquet.
• pip install <paquet> --upgrade : mettre à jour un paquet.
• pip list : lister les paquets installés.

Pour ce cours, les librairies suivantes sont nécessaires :

pip install numpy matplotlib pandas scikit-learn

Une fois installées, il faut les importer dans le code :

import pandas
import matplotlib.pyplot as plt

Les bases du langage Python

Commentaires et docstring

Les commentaires commencent par #. Les docstrings sont des chaînes de caractères placées sous la définition d’une fonction ou d’un module pour en décrire le fonctionnement.

# Définition de la fonction add
def add(a, b):
    """
    Retourne la somme des deux nombres passés en paramètre
    """
    return a + b

# Utilisation
help(add)

Les blocs

En Python, les blocs de code sont définis par l’indentation. Il faut veiller à ne pas mélanger espaces et tabulations.

for i in [1, 2, 3, 4, 5]:
    print(i)

for j in [1, 2, 3, 4, 5]:
    print()
    print(j)
    print(i + j)

print("Fin de bloc")

Une liste de listes s’écrit ainsi :

liste_de_listes = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

Les structures de données

Les chaînes de caractères

chaine1 = 'une chaine'
chaine2 = "une autre chaine"
taille = len(chaine1)
print("La chaine 1 est {0} et a une taille de {1} la chaine 2 est {2}".format(chaine1, taille, chaine2))

chaine3 = chaine1 + chaine2
print(chaine3)

bjr = 'bonjour'
print(bjr[1])    # affiche 'o'
print(bjr[0:2])  # affiche 'bo'
print(bjr[:2])   # affiche 'bo'
print(bjr[2:])   # affiche 'njour'

Les listes

Une liste vide se déclare avec []. On peut y ajouter des éléments avec append.

li = []          # liste vide
li.append(1)      # li = [1]
li.append("bonjour")  # li = [1, "bonjour"]

autre_li = [1, 2, 3, 4, 5]
liste_de_liste = [li, autre_li]  # [[1, "bonjour"], [1, 2, 3, 4, 5]]

print(autre_li[2:4])  # [3, 4]
del autre_li[2:4]     # supprime les éléments aux indices 2 et 3
print(autre_li)       # [1, 2, 5]

print(autre_li[-1])   # 5 (dernier élément)
print(autre_li[-2])   # 2 (avant-dernier élément)

print(len(li))        # taille de la liste
li.extend(autre_li)   # ajoute les éléments de autre_li à li

Les tuples (ou n-uplets)

Les tuples sont des listes immuables, utiles notamment pour récupérer plusieurs valeurs de retour d’une fonction.

def square_and_cube(x):
    return (x * x, x * x * x)

a, b = square_and_cube(3)  # a=9, b=27
_, c = square_and_cube(2)  # _=4 (ignoré), c=8

Les dictionnaires

Les dictionnaires associent des clés à des valeurs.

d = dict()  # dictionnaire vide
nombres = {"un": 0, "deux": 2, "dix": 10}

nombres["un"] = 1        # modifie la valeur associée à "un"
nombres["cinq"] = 5      # ajoute une nouvelle entrée

print(nombres.get("deux"))  # 2
print(nombres.keys())       # liste des clés
print(nombres.values())     # liste des valeurs
print(nombres.items())      # liste des paires (clé, valeur)

for k, v in nombres.items():
    print("La valeur de la clé {} est {}".format(k, v))

Les ensembles

Les ensembles sont des collections sans doublons. Ils supportent les opérations classiques d’ensembles.

ens = set([1, 2, 2, 3, 4, 5])   # ens = {1, 2, 3, 4, 5}
ens2 = set([1, 3, 5, 7])

print(ens & ens2)  # intersection : {1, 3, 5}
print(ens | ens2)  # union : {1, 2, 3, 4, 5, 7}
print(ens - ens2)  # différence : {2, 4}
print(ens ^ ens2)  # différence symétrique : {2, 4, 7}

Les structures de contrôle

Les branchements conditionnels

temp = 10
if temp > 25:
    print("Il fait chaud")
elif temp < 10:
    print("Je mets un pull")
else:
    print("J'hésite")

Les boucles tant que

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

Les boucles for

for x in range(10):
    print(x)  # affiche de 0 à 9

for i in range(2, 4):
    print(i)  # affiche 2, 3

for couleur in ["red", "green", "blue", "white"]:
    print("{} is a color".format(couleur))

Les fonctions

Les fonctions se définissent avec le mot-clé def. Les arguments peuvent être passés par position ou par nom.

def add(a, b):
    print("{} + {} = {}".format(a, b, a + b))
    return a + b

add(3, 4)
add(a=3, b=4)
add(b=4, a=3)

Portée des variables :

x = 42

def set_x(a):
    x = a      # variable locale
    x += 1
    print(x)

def set_global_x(a):
    global x   # variable globale (à éviter)
    x = a
    x += 1
    print(x)

Fonctionnalités avancées

Trier

a = [2, 1, 5, 7, 4]
b = sorted(a)            # b = [1, 2, 4, 5, 7], a inchangé
a.sort()                 # a = [1, 2, 4, 5, 7]

c = sorted(a, reverse=True)  # c = [7, 5, 4, 2, 1]
a.sort(reverse=True)          # a = [7, 5, 4, 2, 1]

Les listes en compréhension

Les listes en compréhension permettent de créer une nouvelle liste à partir d’une transformation ou d’un filtrage d’une autre liste.

liste = [-1, -2, -3, -4, -5]
liste_pos = [abs(x) for x in liste]        # [1, 2, 3, 4, 5]
liste_carre = [x * x for x in liste_pos]   # [1, 4, 9, 16, 25]

cases = [(x, y) for x in range(8) for y in range(8)]
# cases contient toutes les paires (x,y) pour x et y de 0 à 7

Les valeurs aléatoires

import random

random.seed(42)

reel_uniforme_0_1 = random.random()         # nombre réel entre 0 et 1
entier_uniforme_0_4 = random.randrange(5)  # entier entre 0 et 4
entier_uniforme_2_4 = random.randrange(2, 5)  # entier entre 2 et 4

liste = list(range(10))                      # [0,1,2,3,4,5,6,7,8,9]
random.shuffle(liste)                        # mélange la liste aléatoirement
valeur_aleatoire = random.choice(liste)     # choisit un élément au hasard

donnees = list(range(100))                   # [0,...,99]
entrainement = random.sample(donnees, 50)   # 50 valeurs aléatoires distinctes

Glossaire des termes clés

• Environnement virtuel : espace isolé pour installer des paquets Python sans conflit.
• Librairie : ensemble de modules Python pour des fonctionnalités spécifiques.
• Docstring : chaîne de documentation décrivant une fonction ou un module.
• Tuple : structure de données immuable, similaire à une liste.
• Dictionnaire : structure associant des clés à des valeurs.
• Ensemble : collection non ordonnée sans doublons.
• Indentation : espace en début de ligne définissant un bloc de code en Python.
• Liste en compréhension : syntaxe concise pour créer des listes à partir d’autres listes.
• Branchement conditionnel : structure de contrôle permettant d’exécuter du code selon une condition.
• Boucle for : structure répétitive parcourant une séquence.
• Boucle while : structure répétitive exécutant tant qu’une condition est vraie.
• Fonction : bloc de code réutilisable défini avec def.
• Portée des variables : contexte dans lequel une variable est accessible (locale ou globale).
• Tri : opération d’organisation des éléments d’une liste selon un ordre.
• Valeurs aléatoires : nombres ou éléments choisis de manière non déterministe.

Points clés à retenir

• Utiliser un environnement virtuel pour gérer les dépendances Python.
• Installer et importer les librairies nécessaires avec pip et import.
• La syntaxe Python repose sur l’indentation pour définir les blocs de code.
• Les structures de données principales sont les listes, tuples, dictionnaires et ensembles.
• Les boucles et conditions permettent de contrôler le flux d’exécution.
• Les fonctions facilitent la réutilisation et la modularité du code.
• Les listes en compréhension sont un outil puissant pour manipuler les données.
• La bibliothèque random permet de générer des valeurs aléatoires utiles en data science.