Fiche de Révision : Bases de Python

Introduction

Python est un langage de programmation polyvalent, simple et puissant, très utilisé en développement web, data science, automatisation, intelligence artificielle et bien plus. Cette fiche couvre les bases essentielles de Python, adaptée à un niveau intermédiaire, pour consolider vos connaissances et vous préparer à des usages plus avancés.

1. Syntaxe de base et types de données

1.1. Syntaxe générale

• Python utilise l'indentation (4 espaces recommandés) pour délimiter les blocs de code.
• Les commentaires commencent par #.
• La fin d’une instruction ne nécessite pas de point-virgule.

# Exemple simple
if x > 0:
    print("Positif")
else:
    print("Négatif ou zéro")

1.2. Types de données fondamentaux

1.3. Conversion de types

• Conversion explicite avec les fonctions : int(), float(), str(), bool().
• Exemple :

x = "123"
y = int(x)  # conversion en entier

2. Contrôle de flux

2.1. Conditions

if condition:
    # bloc si vrai
elif autre_condition:
    # bloc si autre condition vraie
else:
    # bloc sinon

• Les conditions utilisent les opérateurs : ==, !=, <, >, <=, >=.
• Opérateurs logiques : and, or, not.

2.2. Boucles

• Boucle for : itère sur une séquence (liste, chaîne, range, etc.)

for i in range(5):
    print(i)

• Boucle while : répète tant qu’une condition est vraie

i = 0
while i < 5:
    print(i)
    i += 1

2.3. Instructions de contrôle

• break : sort de la boucle en cours.
• continue : saute à l’itération suivante.
• pass : instruction vide, utile pour placeholder.

3. Fonctions

3.1. Définition et appel

def nom_fonction(param1, param2=10):
    """Docstring: description de la fonction"""
    return param1 + param2

resultat = nom_fonction(5)

• Les paramètres peuvent avoir des valeurs par défaut.
• La fonction retourne une valeur avec return.
• Sans return, la fonction retourne None.

3.2. Arguments variadiques

• *args : arguments positionnels variables (tuple)
• **kwargs : arguments nommés variables (dict)

def f(*args, **kwargs):
    print(args)
    print(kwargs)

f(1, 2, a=3, b=4)

3.3. Fonctions anonymes : lambda

f = lambda x, y: x + y
print(f(3, 4))  # 7

4. Structures de données avancées

4.1. Listes

• Création, accès, modification

lst = [1, 2, 3]
lst.append(4)        # [1, 2, 3, 4]
lst[0] = 10          # [10, 2, 3, 4]
print(lst[1:3])      # sous-liste [2, 3]

• Compréhensions de listes

carrés = [x**2 for x in range(5)]  # [0, 1, 4, 9, 16]

4.2. Dictionnaires

• Stockage clé-valeur, accès rapide

d = {'nom': 'Alice', 'age': 25}
print(d['nom'])       # Alice
d['age'] = 26
d['ville'] = 'Paris'  # ajout d'une clé

• Parcours

for cle, valeur in d.items():
    print(cle, valeur)

4.3. Ensembles (set)

• Collection non ordonnée d’éléments uniques

s = {1, 2, 3, 3}
print(s)   # {1, 2, 3}

• Opérations ensemblistes : union, intersection, différence

5. Programmation orientée objet (POO)

5.1. Classes et objets

class Personne:
    def __init__(self, nom, age):
        self.nom = nom
        self.age = age

    def bonjour(self):
        print(f"Bonjour, je m'appelle {self.nom} et j'ai {self.age} ans.")

p = Personne("Alice", 30)
p.bonjour()

• __init__ : constructeur
• self : référence à l'instance
• Méthodes : fonctions associées à la classe

5.2. Héritage

class Etudiant(Personne):
    def __init__(self, nom, age, etudes):
        super().__init__(nom, age)
        self.etudes = etudes

    def bonjour(self):
        super().bonjour()
        print(f"Je suis étudiant en {self.etudes}.")

• Permet de spécialiser une classe par héritage.

6. Gestion des erreurs

6.1. Bloc try-except

try:
    x = int(input("Entrez un nombre: "))
except ValueError:
    print("Ce n'est pas un nombre valide")
else:
    print(f"Vous avez entré {x}")
finally:
    print("Fin du programme")

• try : code à risque d’erreur
• except : gestion de l’erreur
• else : code si pas d’erreur
• finally : code toujours exécuté

7. Modules et packages

7.1. Importer un module

import math
print(math.sqrt(16))  # 4.0

7.2. Importer des fonctions spécifiques

from math import sqrt, pi
print(pi)

7.3. Création de modules

• Un fichier .py est un module.
• Organiser le code en modules facilite la maintenance.

8. Manipulation de fichiers

8.1. Lecture et écriture

# Écriture
with open("fichier.txt", "w") as f:
    f.write("Bonjour\n")

# Lecture
with open("fichier.txt", "r") as f:
    contenu = f.read()
    print(contenu)

• with assure la fermeture du fichier même en cas d’erreur.
• Modes : "r" lecture, "w" écriture, "a" ajout.

9. Expressions régulières (regex)

• Utilisées pour rechercher, extraire ou remplacer des motifs dans les chaînes.

import re

texte = "Email: alice@example.com"
match = re.search(r"\w+@\w+\.\w+", texte)
if match:
    print(match.group())  # alice@example.com

10. Concepts avancés en bref

10.1. Compréhensions avancées

• Listes, dictionnaires, ensembles

carres = {x: x**2 for x in range(5)}  # dict comprehension

10.2. Générateurs

• Fonction utilisant yield pour produire une séquence paresseuse

def compte():
    n = 0
    while True:
        yield n
        n += 1

gen = compte()
print(next(gen))  # 0
print(next(gen))  # 1

10.3. Décorateurs

• Fonctions modifiant le comportement d’autres fonctions

def decorateur(f):
    def wrapper():
        print("Avant")
        f()
        print("Après")
    return wrapper

@decorateur
def salut():
    print("Salut!")

salut()

Diagramme des concepts clés de Python

[Diagramme]

Citation importante

"La simplicité est la sophistication suprême." – Léonard de Vinci
En Python, privilégier un code clair et lisible facilite le développement et la maintenance.

Conclusion

Cette fiche couvre les fondations solides de Python nécessaires pour avancer vers des projets complexes. Maîtriser ces bases vous permettra de comprendre facilement des bibliothèques externes et d’écrire des programmes robustes et efficaces.

Annexes : Résumé des fonctions utiles

Exercices recommandés

1. Écrire une fonction qui calcule la factorielle d’un nombre avec récursion.
2. Créer une classe CompteBancaire avec dépôt, retrait et affichage du solde.
3. Manipuler un fichier CSV pour extraire des données et les convertir en dictionnaire.
4. Écrire un générateur qui produit une suite de Fibonacci.

Bonne révision et programmation en Python !