Introduction à Python
Python est un langage de programmation de haut niveau, interprété et polyvalent, créé par Guido van Rossum et publié pour la première fois en 1991. Python est aujourd'hui l'un des langages les plus populaires au monde, utilisé dans de nombreux domaines : développement web, data science, intelligence artificielle, automatisation, et bien plus encore.
🐍 Qu'est-ce que Python ?
Python est un langage de programmation interprété et orienté objet. Contrairement aux langages compilés comme C++ ou Java, Python exécute le code ligne par ligne, ce qui le rend plus facile à déboguer et à tester. Sa syntaxe simple et lisible le rend idéal pour les débutants comme pour les experts.
💡 Pourquoi Python est si populaire ?
- Syntaxe simple et lisible - Le code Python ressemble presque à de l'anglais, ce qui le rend facile à apprendre et à comprendre
- Polyvalent - Utilisé pour le web (Django, Flask), la data science (Pandas, NumPy), l'IA (TensorFlow, PyTorch), l'automatisation
- Vaste bibliothèque standard - Des milliers de modules disponibles pour presque tous les besoins
- Communauté active - Des millions de développeurs dans le monde, documentation complète, nombreuses ressources d'apprentissage
- Open-source et gratuit - Aucun coût de licence, multiplateforme (Windows, Linux, macOS)
- Multi-paradigme - Supporte la programmation procédurale, orientée objet et fonctionnelle
🚀 Pourquoi apprendre Python ?
Python est un excellent choix pour débuter en programmation pour plusieurs raisons :
- ✅ Facile à apprendre - Syntaxe claire et intuitive, parfaite pour les débutants. La courbe d'apprentissage est douce comparée à d'autres langages
- ✅ Polyvalent - Développement web (Django, Flask), data science (Pandas, NumPy), IA (TensorFlow, PyTorch), automatisation, scripts système
- ✅ Très demandé - L'un des langages les plus recherchés sur le marché du travail. Utilisé par Google, Facebook, Netflix, Instagram, Spotify
- ✅ Gratuit et Open-Source - Aucun coût, multiplateforme, communauté active
- ✅ Vaste écosystème - Des milliers de bibliothèques disponibles via pip (gestionnaire de paquets Python)
- ✅ Grande communauté - Support et ressources abondantes, forums actifs, tutoriels gratuits
- ✅ Rapidité de développement - Permet de développer rapidement des prototypes et applications
📋 Prérequis pour apprendre Python
Python est si simple que vous pouvez commencer sans aucune expérience préalable ! Cependant, avoir des connaissances de base en :
- ✅ Informatique de base - Savoir utiliser un ordinateur, créer et éditer des fichiers
- ✅ Logique - Comprendre les concepts de base (variables, conditions, boucles) est utile mais pas obligatoire, vous les apprendrez avec Python
💡 Note importante : Python est installé par défaut sur Linux et macOS. Pour Windows, vous pouvez télécharger Python depuis python.org. Vous pouvez aussi utiliser un IDE comme PyCharm, VS Code, ou simplement l'interpréteur Python en ligne de commande. Pour tester rapidement, vous pouvez utiliser des environnements en ligne comme Repl.it ou Python.org/shell.
🎯 Cas d'usage de Python
Python est utilisé dans de nombreux domaines :
- Développement web - Django, Flask pour créer des sites web et API REST. Frameworks modernes et puissants
- Data Science - Analyse de données, visualisation avec Pandas, NumPy, Matplotlib. Très utilisé dans la finance et la recherche
- Intelligence Artificielle - Machine Learning, Deep Learning avec TensorFlow, PyTorch, Scikit-learn
- Automatisation - Scripts pour automatiser des tâches répétitives, traitement de fichiers, web scraping
- Applications desktop - Tkinter, PyQt pour créer des interfaces graphiques multiplateformes
- Développement de jeux - Pygame pour créer des jeux vidéo 2D
- Scraping web - BeautifulSoup, Scrapy pour extraire des données de sites web
- Calcul scientifique - NumPy, SciPy pour les calculs mathématiques et scientifiques
📝 Syntaxe de base
La syntaxe Python est simple et lisible. Python utilise l'indentation (espaces ou tabulations) pour définir les blocs de code, contrairement à d'autres langages qui utilisent des accolades {} ou des mots-clés comme begin/end.
# Premier programme Python
print("Bonjour, monde !")
# Variables
nom = "NiangProgrammeur"
age = 25
# F-strings pour formater les chaînes (Python 3.6+)
print(f"Je m'appelle {nom} et j'ai {age} ans")
# Opérations simples
resultat = 10 + 5
print(f"10 + 5 = {resultat}")💡 Points importants sur la syntaxe Python :
- Python est sensible à l'indentation - Utilisez 4 espaces (recommandé par PEP 8) ou des tabulations de manière cohérente. L'indentation définit les blocs de code
- Les commentaires commencent par
#pour une ligne, ou"""pour plusieurs lignes (docstrings) - Pas besoin de point-virgule à la fin des lignes (contrairement à C, Java, PHP)
- Les chaînes de caractères peuvent utiliser des guillemets simples
'ou doubles". Les f-strings (f"...") permettent l'interpolation - Les deux-points
:marquent le début d'un bloc (après if, for, def, class, etc.) - PEP 8 est le guide de style officiel pour écrire du code Python lisible
🔍 Exemple détaillé de syntaxe
Voici un exemple complet montrant plusieurs aspects de la syntaxe Python :
# Définition d'une fonction
def calculer_moyenne(nombres):
"""Calcule la moyenne d'une liste de nombres."""
if len(nombres) == 0:
return 0
somme = sum(nombres)
moyenne = somme / len(nombres)
return moyenne
# Utilisation
notes = [15, 18, 12, 20, 16]
moyenne = calculer_moyenne(notes)
print(f"La moyenne est : {moyenne}")🔤 Variables
En Python, les variables sont créées simplement en leur assignant une valeur. Vous n'avez pas besoin de déclarer le type de variable explicitement. Python est un langage à typage dynamique, ce qui signifie que le type est déterminé automatiquement à l'exécution.
# Déclaration de variables
nom = "Python" # String (chaîne de caractères)
age = 30 # Integer (entier)
prix = 19.99 # Float (nombre décimal)
est_actif = True # Boolean (booléen)
valeur_nulle = None # NoneType (valeur nulle)
# Affichage
print(nom)
print(age)
print(prix)
print(est_actif)
print(valeur_nulle)
# Réassignation (changement de type)
variable = 10
print(type(variable)) #
variable = "Dix"
print(type(variable)) #
# Noms de variables valides
nom_utilisateur = "Bassirou"
age_utilisateur = 25
_privé = "variable privée"
CONSTANTE = 3.14159 # Convention pour les constantes 📌 Règles pour les noms de variables :
- Doivent commencer par une lettre ou un underscore
_ - Peuvent contenir des lettres, chiffres et underscores
- Ne peuvent pas contenir d'espaces (utilisez
_à la place) - Sont sensibles à la casse (
age≠Age) - Ne peuvent pas être des mots-clés Python (
if,for,def, etc.) - Convention : utilisez
snake_casepour les variables (PEP 8)
📊 Types de données
Python a plusieurs types de données intégrés (built-in types). Voici les principaux :
# Types de base (scalaires)
texte = "Hello" # str (string)
nombre = 42 # int (integer)
decimal = 3.14 # float (floating point)
booleen = True # bool (boolean)
valeur_nulle = None # NoneType
# Collections (structures de données)
liste = [1, 2, 3, 4, 5] # list (liste ordonnée, modifiable)
tuple = (1, 2, 3) # tuple (liste ordonnée, immuable)
dictionnaire = {"nom": "Python", "age": 30} # dict (paires clé-valeur)
ensemble = {1, 2, 3, 4} # set (ensemble unique, non ordonné)
# Vérifier le type
print(type(texte)) #
print(type(nombre)) #
print(type(liste)) #
print(type(dictionnaire)) #
# Conversion de types
age_str = str(25) # Convertir en string
age_int = int("25") # Convertir en entier
prix_float = float("19.99") # Convertir en décimal 📚 Types de données Python :
- str - Chaînes de caractères (texte)
- int - Nombres entiers (positifs, négatifs, zéro)
- float - Nombres décimaux (virgule flottante)
- bool - Booléens (True ou False)
- list - Listes ordonnées et modifiables
- tuple - Tuples ordonnés et immuables
- dict - Dictionnaires (paires clé-valeur)
- set - Ensembles (éléments uniques, non ordonnés)
- NoneType - Type pour la valeur None (équivalent à null)
🔢 Opérateurs
Python supporte les opérateurs arithmétiques, de comparaison, logiques, d'assignation et d'identité :
# Opérateurs arithmétiques
a = 10
b = 3
print(a + b) # Addition: 13
print(a - b) # Soustraction: 7
print(a * b) # Multiplication: 30
print(a / b) # Division: 3.3333333333333335
print(a // b) # Division entière: 3
print(a % b) # Modulo (reste): 1
print(a ** b) # Puissance: 1000
# Opérateurs de comparaison
print(a > b) # True (supérieur à)
print(a < b) # False (inférieur à)
print(a >= b) # True (supérieur ou égal)
print(a <= b) # False (inférieur ou égal)
print(a == b) # False (égalité)
print(a != b) # True (différent)
# Opérateurs logiques
x = True
y = False
print(x and y) # False (ET logique)
print(x or y) # True (OU logique)
print(not x) # False (NON logique)
# Opérateurs d'assignation
c = 5
c += 3 # Équivalent à c = c + 3 (c devient 8)
c -= 2 # Équivalent à c = c - 2 (c devient 6)
c *= 2 # Équivalent à c = c * 2 (c devient 12)
c /= 3 # Équivalent à c = c / 3 (c devient 4.0)
# Opérateurs d'identité
liste1 = [1, 2, 3]
liste2 = [1, 2, 3]
liste3 = liste1
print(liste1 is liste2) # False (objets différents)
print(liste1 is liste3) # True (même objet)
print(liste1 == liste2) # True (valeurs égales)🔀 Structures conditionnelles
Python utilise if, elif (else if) et else pour les conditions. L'indentation est cruciale pour définir les blocs de code.
# Structure if simple
age = 20
if age >= 18:
print("Vous êtes majeur")
else:
print("Vous êtes mineur")
# Structure if/elif/else
age = 15
if age >= 18:
print("Vous êtes majeur")
print("Vous pouvez voter")
elif age >= 13:
print("Vous êtes adolescent")
elif age >= 6:
print("Vous êtes enfant")
else:
print("Vous êtes un bébé")
# Conditions multiples
note = 85
if note >= 90:
mention = "Excellent"
elif note >= 80:
mention = "Très bien"
elif note >= 70:
mention = "Bien"
elif note >= 60:
mention = "Assez bien"
else:
mention = "Insuffisant"
print(f"Votre mention : {mention}")
# Opérateur ternaire (expression conditionnelle)
age = 20
statut = "Majeur" if age >= 18 else "Mineur"
print(statut)
# Conditions avec and/or
age = 25
permis = True
if age >= 18 and permis:
print("Vous pouvez conduire")
else:
print("Vous ne pouvez pas conduire")🔄 Boucles
Python propose deux types de boucles : for (pour itérer sur une séquence) et while (pour répéter tant qu'une condition est vraie) :
# Boucle for avec range()
for i in range(5):
print(i) # Affiche 0, 1, 2, 3, 4
# range() avec début et fin
for i in range(1, 6):
print(i) # Affiche 1, 2, 3, 4, 5
# range() avec pas
for i in range(0, 10, 2):
print(i) # Affiche 0, 2, 4, 6, 8
# Boucle for avec liste
fruits = ["pomme", "banane", "orange"]
for fruit in fruits:
print(f"J'aime les {fruit}")
# Boucle for avec index (enumerate)
fruits = ["pomme", "banane", "orange"]
for index, fruit in enumerate(fruits):
print(f"{index}: {fruit}")
# Boucle while
compteur = 0
while compteur < 5:
print(compteur)
compteur += 1
# Boucle while avec break
compteur = 0
while True:
print(compteur)
compteur += 1
if compteur >= 5:
break # Sortir de la boucle
# continue (passer à l'itération suivante)
for i in range(10):
if i % 2 == 0: # Si i est pair
continue # Passer au suivant
print(i) # Affiche seulement les impairs: 1, 3, 5, 7, 9
# Boucle for avec else
for i in range(5):
print(i)
else:
print("Boucle terminée") # Exécuté si la boucle se termine normalement⚙️ Fonctions
Les fonctions permettent de réutiliser du code. En Python, on définit une fonction avec def. Les fonctions peuvent prendre des paramètres et retourner des valeurs avec return.
# Fonction simple (sans paramètres)
def dire_bonjour():
print("Bonjour !")
dire_bonjour() # Appel de la fonction
# Fonction avec paramètres
def saluer(nom):
return f"Bonjour, {nom} !"
message = saluer("Python")
print(message) # "Bonjour, Python !"
# Fonction avec plusieurs paramètres
def additionner(a, b):
return a + b
resultat = additionner(5, 3)
print(resultat) # 8
# Fonction avec paramètres par défaut
def saluer_personne(nom, message="Bonjour"):
return f"{message}, {nom} !"
print(saluer_personne("Bassirou")) # "Bonjour, Bassirou !"
print(saluer_personne("Bassirou", "Salut")) # "Salut, Bassirou !"
# Fonction avec arguments nommés
def creer_personne(nom, age, ville="Dakar"):
return f"{nom}, {age} ans, habite à {ville}"
print(creer_personne("Bassirou", 25))
print(creer_personne(age=25, nom="Bassirou", ville="Thiès"))
# Fonction avec *args (arguments variables)
def additionner_nombres(*args):
return sum(args)
print(additionner_nombres(1, 2, 3, 4, 5)) # 15
# Fonction avec **kwargs (arguments nommés variables)
def afficher_info(**kwargs):
for cle, valeur in kwargs.items():
print(f"{cle}: {valeur}")
afficher_info(nom="Bassirou", age=25, ville="Dakar")
# Fonction lambda (fonction anonyme)
carre = lambda x: x ** 2
print(carre(5)) # 25
# Utilisation de lambda avec map()
nombres = [1, 2, 3, 4, 5]
carres = list(map(lambda x: x ** 2, nombres))
print(carres) # [1, 4, 9, 16, 25]📋 Listes et Dictionnaires
Les listes et dictionnaires sont des structures de données très utiles en Python. Les listes sont ordonnées et modifiables, les dictionnaires stockent des paires clé-valeur.
# ========== LISTES ==========
# Création de listes
nombres = [1, 2, 3, 4, 5]
fruits = ["pomme", "banane", "orange"]
liste_mixte = [1, "deux", 3.0, True]
# Accès aux éléments (index commence à 0)
print(fruits[0]) # "pomme" (premier élément)
print(fruits[-1]) # "orange" (dernier élément)
# Modification
fruits[1] = "mangue" # Remplacer "banane" par "mangue"
# Méthodes des listes
fruits.append("kiwi") # Ajouter à la fin
fruits.insert(1, "ananas") # Insérer à l'index 1
fruits.remove("pomme") # Supprimer un élément
fruits.pop() # Supprimer le dernier élément
fruits.pop(0) # Supprimer l'élément à l'index 0
# Autres méthodes utiles
print(len(fruits)) # Longueur de la liste
print(fruits.count("banane")) # Compter les occurrences
fruits.sort() # Trier la liste
fruits.reverse() # Inverser la liste
# Slicing (tranches)
nombres = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(nombres[2:5]) # [2, 3, 4] (de l'index 2 à 4)
print(nombres[:3]) # [0, 1, 2] (du début à l'index 2)
print(nombres[3:]) # [3, 4, 5, 6, 7, 8, 9] (de l'index 3 à la fin)
print(nombres[::2]) # [0, 2, 4, 6, 8] (tous les 2 éléments)
# ========== DICTIONNAIRES ==========
# Création de dictionnaires
personne = {
"nom": "Bassirou",
"age": 25,
"ville": "Dakar"
}
# Accès aux valeurs
print(personne["nom"]) # "Bassirou"
print(personne.get("age")) # 25 (méthode get() plus sûre)
print(personne.get("email", "Non renseigné")) # Valeur par défaut
# Modification et ajout
personne["age"] = 26 # Modifier
personne["email"] = "bassirou@example.com" # Ajouter
# Méthodes des dictionnaires
print(personne.keys()) # Toutes les clés
print(personne.values()) # Toutes les valeurs
print(personne.items()) # Toutes les paires clé-valeur
# Parcourir un dictionnaire
for cle, valeur in personne.items():
print(f"{cle}: {valeur}")
# Supprimer
del personne["email"] # Supprimer une clé
personne.pop("ville") # Supprimer et retourner la valeur📦 Modules
Python permet d'importer des modules pour étendre ses fonctionnalités. Un module est un fichier contenant des fonctions, classes et variables que vous pouvez réutiliser.
# Importer un module complet
import math
print(math.sqrt(16)) # 4.0 (racine carrée)
print(math.pi) # 3.141592653589793
print(math.cos(0)) # 1.0
# Importer avec un alias
import datetime as dt
maintenant = dt.datetime.now()
print(maintenant)
# Importer des fonctions spécifiques
from math import sqrt, pi
print(sqrt(25)) # 5.0
print(pi) # 3.141592653589793
# Importer tout d'un module (non recommandé)
from math import *
print(sin(0)) # 0.0
# Modules standards utiles
import random
print(random.randint(1, 100)) # Nombre aléatoire entre 1 et 100
import os
print(os.getcwd()) # Répertoire courant
import sys
print(sys.version) # Version de Python
# Créer son propre module
# Créer un fichier mon_module.py avec :
# def ma_fonction():
# return "Hello from module"
#
# Puis l'importer :
# import mon_module
# print(mon_module.ma_fonction())🏗️ Programmation Orientée Objet
Python supporte la programmation orientée objet (POO). Une classe est un modèle pour créer des objets. Les objets ont des attributs (données) et des méthodes (fonctions).
# Définir une classe
class Personne:
# Constructeur (méthode spéciale __init__)
def __init__(self, nom, age):
self.nom = nom # Attribut d'instance
self.age = age
# Méthode d'instance
def se_presenter(self):
return f"Je m'appelle {self.nom} et j'ai {self.age} ans"
def avoir_ans(self, annees):
self.age += annees
return f"Dans {annees} ans, j'aurai {self.age} ans"
# Créer des objets (instances)
personne1 = Personne("Bassirou", 25)
personne2 = Personne("Aminata", 30)
# Utiliser les méthodes
print(personne1.se_presenter())
print(personne2.se_presenter())
print(personne1.avoir_ans(5))
# Accéder aux attributs
print(personne1.nom)
print(personne1.age)
# Classe avec attributs de classe
class Voiture:
# Attribut de classe (partagé par toutes les instances)
nombre_voitures = 0
def __init__(self, marque, modele):
self.marque = marque
self.modele = modele
Voiture.nombre_voitures += 1
def __str__(self):
return f"{self.marque} {self.modele}"
voiture1 = Voiture("Toyota", "Corolla")
voiture2 = Voiture("Honda", "Civic")
print(f"Nombre de voitures créées : {Voiture.nombre_voitures}")
# Héritage
class Etudiant(Personne):
def __init__(self, nom, age, ecole):
super().__init__(nom, age) # Appeler le constructeur parent
self.ecole = ecole
def etudier(self):
return f"{self.nom} étudie à {self.ecole}"
etudiant = Etudiant("Bassirou", 25, "UCAD")
print(etudiant.se_presenter()) # Méthode héritée
print(etudiant.etudier()) # Méthode spécifique📁 Manipulation de fichiers
Python permet de lire et écrire dans des fichiers facilement. Il est recommandé d'utiliser with pour garantir la fermeture automatique du fichier.
# Écrire dans un fichier (mode 'w' = write)
with open("fichier.txt", "w", encoding="utf-8") as f:
f.write("Bonjour Python !\n")
f.write("Ceci est la deuxième ligne\n")
# Lire un fichier (mode 'r' = read)
with open("fichier.txt", "r", encoding="utf-8") as f:
contenu = f.read()
print(contenu)
# Lire ligne par ligne
with open("fichier.txt", "r", encoding="utf-8") as f:
for ligne in f:
print(ligne.strip()) # strip() enlève les sauts de ligne
# Lire toutes les lignes dans une liste
with open("fichier.txt", "r", encoding="utf-8") as f:
lignes = f.readlines()
print(lignes)
# Ajouter à un fichier (mode 'a' = append)
with open("fichier.txt", "a", encoding="utf-8") as f:
f.write("Nouvelle ligne ajoutée\n")
# Modes de fichier
# 'r' - Lecture (défaut)
# 'w' - Écriture (écrase le fichier existant)
# 'a' - Ajout (ajoute à la fin)
# 'x' - Création exclusive (erreur si existe)
# 'b' - Mode binaire (rb, wb)
# 't' - Mode texte (défaut, rt, wt)
# '+' - Lecture et écriture (r+, w+, a+)
# Gestion d'erreurs
try:
with open("fichier_inexistant.txt", "r") as f:
contenu = f.read()
except FileNotFoundError:
print("Le fichier n'existe pas")
except PermissionError:
print("Permission refusée")
except Exception as e:
print(f"Erreur : {e}")💡 Bonne pratique : Utilisez toujours with pour ouvrir les fichiers. Cela garantit que le fichier sera fermé automatiquement même en cas d'erreur. C'est la méthode recommandée en Python et cela évite les fuites de ressources !
🎓 Prochaines étapes
Félicitations ! Vous avez maintenant une solide base en Python.
✅ Ce que vous avez appris :
- Syntaxe Python et variables
- Types de données (str, int, float, bool, list, dict, tuple, set)
- Opérateurs (arithmétiques, comparaison, logiques)
- Structures conditionnelles (if, elif, else)
- Boucles (for et while)
- Fonctions (définition, paramètres, return, lambda)
- Listes et dictionnaires (méthodes, slicing)
- Modules (import, création)
- Programmation Orientée Objet (classes, objets, héritage)
- Manipulation de fichiers (lecture, écriture, gestion d'erreurs)
🚀 Pour aller plus loin :
- Compréhensions de listes - Syntaxe concise pour créer des listes
- Gestion des exceptions - try/except pour gérer les erreurs
- Packages et pip - Installer des bibliothèques externes
- Développement web - Django ou Flask pour créer des sites web
- Data Science - Pandas, NumPy pour l'analyse de données
- Intelligence Artificielle - TensorFlow, PyTorch pour le Machine Learning