Déclaration de variables

En Python, les variables sont créées lorsqu'on leur assigne une valeur. Pas besoin de déclarer le type explicitement.

# Déclaration de variables
nom = "Valentin"
age = 23
taille = 1.70
est_etudiant = True

Types de données de base

Conversion de types

Vous pouvez convertir entre différents types avec les fonctions int(), float(), str(), etc.

# Conversion de types
nombre = "123"
nombre_entier = int(nombre)  # Convertit en entier
nombre_flottant = float(nombre)  # Convertit en flottant

texte = str(42)  # Convertit en chaîne de caractères

Opérateurs arithmétiques

Python supporte les opérations mathématiques de base :

Priorité des opérateurs

Les opérations sont évaluées selon cet ordre de priorité :

1. () Parenthèses
2. ** Exponentiation
3. *, /, //, %
4. +, -

# Exemple de priorité
resultat = 5 + 3 * 2  # → 11 (pas 16)
resultat = (5 + 3) * 2  # → 16

Opérateurs de comparaison

Ces opérateurs retournent True or False :

# Exemples de comparaison
age = 18
majeur = age >= 18  # → True
print(majeur)

Instruction if

La structure if permet d'exécuter un bloc de code seulement si une condition est vraie.

# Syntaxe de base
if condition:
    # Code à exécuter si condition est True
    print("La condition est vraie")

# Exemple pratique
age = 20

if age >= 18:
    print("Vous êtes majeur")

if...else

L'instruction else permet d'exécuter un bloc alternatif si la condition est fausse.

# Syntaxe if...else
if condition:
    # Code si condition vraie
else:
    # Code si condition fausse

# Exemple pratique
age = 16

if age >= 18:
    print("Vous êtes majeur")
else:
    print("Vous êtes mineur")

if...elif...else

Pour tester plusieurs conditions, on utilise elif (contraction de "else if").

# Syntaxe if...elif...else
if condition1:
    # Code si condition1 vraie
elif condition2:
    # Code si condition2 vraie
else:
    # Code si aucune condition vraie

# Exemple pratique
note = 14

if note >= 16:
    print("Très bien")
elif note >= 14:
    print("Bien")
elif note >= 12:
    print("Assez bien")
else:
    print("Insuffisant")

Conditions imbriquées

Il est possible d'imbriquer des conditions à l'intérieur d'autres conditions.

# Exemple de conditions imbriquées
age = 20
permis = True

if age >= 18:
    if permis:
        print("Vous pouvez conduire")
    else:
        print("Vous avez l'âge mais pas le permis")
else:
    print("Vous êtes trop jeune")

Boucle while

La boucle while répète un bloc de code tant qu'une condition est vraie.

# Syntaxe de while
while condition:
    # Code à répéter
    print("La condition est vraie")

# Exemple pratique - compte à rebours
compteur = 5

while compteur > 0:
    print(compteur)
    compteur -= 1  # équivalent à compteur = compteur - 1

print("Décollage !")

Boucle for

La boucle for permet d'itérer sur une séquence (liste, chaîne de caractères, etc.).

# Syntaxe de for
for element in sequence:
    # Code à exécuter pour chaque élément
    print(element)

# Exemple pratique - itération sur une liste
fruits = ["pomme", "banane", "orange"]

for fruit in fruits:
    print(fruit)

# Exemple pratique - itération sur une chaîne
mot = "Python"

for lettre in mot:
    print(lettre)

Fonction range()

range() génère une séquence de nombres, utile pour les boucles.

# Syntaxe de range
range(début, fin, pas)  # fin est exclue

# Exemples
for i in range(5):      # 0, 1, 2, 3, 4
    print(i)

for i in range(1, 6):   # 1, 2, 3, 4, 5
    print(i)

for i in range(0, 10, 2):  # 0, 2, 4, 6, 8
    print(i)

Instructions break et continue

# Exemple de break
for i in range(10):
    if i == 5:
        break
    print(i)  # Affiche 0, 1, 2, 3, 4

# Exemple de continue
for i in range(5):
    if i == 2:
        continue
    print(i)  # Affiche 0, 1, 3, 4

Boucles imbriquées

Il est possible d'imbriquer des boucles à l'intérieur d'autres boucles.

# Exemple de boucles imbriquées
for i in range(3):      # Boucle externe
    for j in range(2):  # Boucle interne
        print(f"i={i}, j={j}")

# Table de multiplication
for i in range(1, 11):
    for j in range(1, 11):
        print(f"{i} x {j} = {i*j}")
    print()  # Ligne vide entre les tables

Définition de fonctions

Une fonction est un bloc de code réutilisable qui effectue une tâche spécifique.

# Syntaxe de base
def nom_de_la_fonction(paramètres):
    """Docstring (description de la fonction)"""
    # Corps de la fonction
    return résultat  # Optionnel

# Exemple simple
def saluer(nom):
    """Affiche un message de salutation"""
    print(f"Bonjour, {nom} !")

# Appel de la fonction
saluer("Valentin")  # Affiche "Bonjour, Valentin !"

Valeurs de retour

Une fonction peut retourner une valeur avec return. Si aucun return n'est spécifié, la fonction retourne None.

# Fonction avec retour
def carre(x):
    """Retourne le carré d'un nombre"""
    return x ** 2

resultat = carre(4)  # resultat = 16

# Fonction sans return explicite
def afficher_carre(x):
    """Affiche le carré d'un nombre"""
    print(x ** 2)

resultat = afficher_carre(4)  # Affiche 16, resultat = None

# Retour multiple
def operations(x, y):
    """Retourne plusieurs résultats"""
    return x + y, x - y, x * y, x / y

somme, difference, produit, quotient = operations(10, 2)

Paramètres et arguments

Paramètres positionnels

Les arguments sont assignés aux paramètres dans l'ordre.

def soustraire(a, b):
    return a - b

resultat = soustraire(5, 3)  # a=5, b=3 → 2

Arguments nommés

Permettent de spécifier les arguments par nom, indépendamment de l'ordre.

resultat = soustraire(b=3, a=5)  # Même résultat que précédemment

Valeurs par défaut

Les paramètres peuvent avoir des valeurs par défaut.

def saluer(nom, message="Bonjour"):
    print(f"{message}, {nom} !")

saluer("Valentin")           # "Bonjour, Valentin !"
saluer("Bob", "Salut")    # "Salut, Bob !"

Portée des variables

Les variables définies dans une fonction sont locales à cette fonction. Pour modifier une variable globale, utilisez le mot-clé global.

# Variable globale
compteur = 0

def incrementer():
    global compteur  # Référence à la variable globale
    compteur += 1

incrementer()
print(compteur)  # 1

# Variable locale
def test():
    variable_locale = 10
    print(variable_locale)

test()
print(variable_locale)  # Erreur: variable_locale n'est pas définie

Exercice 1 : Calculatrice simple

Créez un programme qui demande deux nombres et une opération (+, -, *, /) à l'utilisateur, puis affiche le résultat.

# Solution
nombre1 = float(input("Entrez le premier nombre : "))
nombre2 = float(input("Entrez le deuxième nombre : "))
operation = input("Entrez l'opération (+, -, *, /) : ")

if operation == '+':
    resultat = nombre1 + nombre2
elif operation == '-':
    resultat = nombre1 - nombre2
elif operation == '*':
    resultat = nombre1 * nombre2
elif operation == '/':
    if nombre2 == 0:
        print("Erreur : division par zéro")
        resultat = None
    else:
        resultat = nombre1 / nombre2
else:
    print("Opération non reconnue")
    resultat = None

if resultat is not None:
    print(f"Résultat : {resultat}")

Exercice 2 : Deviner le nombre

Créez un jeu où l'ordinateur choisit un nombre aléatoire entre 1 et 100, et l'utilisateur doit le deviner.

# Solution
import random

nombre_a_deviner = random.randint(1, 100)
tentatives = 0

print("J'ai choisi un nombre entre 1 and 100. Devinez lequel !")

while True:
    tentative = int(input("Votre proposition : "))
    tentatives += 1
    
    if tentative < nombre_a_deviner:
        print("Trop petit !")
    elif tentative > nombre_a_deviner:
        print("Trop grand !")
    else:
        print(f"Bravo ! Vous avez trouvé en {tentatives} tentatives.")
        break

Exercice 3 : FizzBuzz

Écrivez un programme qui affiche les nombres de 1 à 100 avec les règles suivantes :

• Pour les multiples de 3, affichez "Fizz" au lieu du nombre
• Pour les multiples de 5, affichez "Buzz" au lieu du nombre
• Pour les multiples de 3 et 5, affichez "FizzBuzz"

# Solution
for i in range(1, 101):
    if i % 15 == 0:  # Multiple de 3 et 5
        print("FizzBuzz")
    elif i % 3 == 0:
        print("Fizz")
    elif i % 5 == 0:
        print("Buzz")
    else:
        print(i)

Les listes et les tuples sont des structures de données fondamentales en Python pour stocker des collections d'éléments.
La principale différence est que les listes sont modifiables (mutables) tandis que les tuples sont immuables. Choisissez un tuple lorsque vos données ne doivent pas changer.

1. Travailler avec les Listes

Création et accès

# Création d'une liste
  fruits = ["pomme", "banane", "cerise"]
  
  # Accès par index (0-based)
  print(fruits[0])     # 'pomme'
  print(fruits[-1])    # 'cerise' (dernier élément)

Slicing

Extraire un sous-ensemble :

# Syntaxe : liste[début:fin:pas]
  print(fruits[0:2])   # ['pomme', 'banane']
  print(fruits[::2])   # ['pomme', 'cerise'] (tous les 2)

Méthodes utiles

• append(x) : ajoute x à la fin
• insert(i, x) : insère x à l'index i
• remove(x) : supprime la première occurrence de x
• pop([i]) : retire et renvoie l'élément à l'index i (dernier par défaut)
• sort() et sorted() : tri
• reverse() : inverse l'ordre

# Exemple complet
  nombres = [3, 1, 4, 1, 5]
  nombres.append(9)
  nombres.insert(2, 2)
  nombres.remove(1)
  nombres.sort()
  print(nombres)   # [1, 2, 3, 4, 5, 9]

List Comprehension

Construire une nouvelle liste de façon concise :

# Carrés des nombres de 1 à 5
  carres = [x**2 for x in range(1, 6)]
  print(carres)   # [1, 4, 9, 16, 25]
  
  # Filtrer
  pairs = [x for x in range(1, 11) if x % 2 == 0]
  print(pairs)    # [2, 4, 6, 8, 10]

2. Travailler avec les Tuples

Création et Accès

# Création d'un tuple
  coordonnees = (10.0, 20.0)
  
  # Accès
  x, y = coordonnees    # Unpacking
  print(x, y)           # 10.0 20.0

Usages courants

• Retour multiple depuis une fonction
• Clés immuables pour un dict
• Permutation de variables sans temporaire : a, b = b, a

# Exemple : fonction retournant plusieurs valeurs
  def operations(a, b):
      return a+b, a-b, a*b, (a/b if b else None)
  
  somme, diff, prod, quot = operations(8, 2)
  print(somme, diff, prod, quot)  # 10 6 16 4.0

1. Création & accès

Un dictionnaire est une collection non ordonnée de paires clé → valeur.

# Création
  mon_dict = {
      "nom": "Valentin",
      "age": 23,
      "skills": ["Python", "C"]
  }
  
  # Accès sécurisé
  print(mon_dict["nom"])          # Valentin
  print(mon_dict.get("age"))      # 23
  print(mon_dict.get("ville", "Inconnue"))  # Inconnue
  

2. Ajout, mise à jour & suppression

# Ajout ou mise à jour
  mon_dict["ville"] = "Paris"   # ajout
  mon_dict["age"] = 26          # mise à jour
  
  # Suppression
  del mon_dict["skills"]        # sans retour
  ancien_age = mon_dict.pop("age")  # récupère et supprime
  

3. Parcours & méthodes utiles

# Parcours complet
  for cle, val in mon_dict.items():
      print(f"{cle} → {val}")
  
  # Liste des clés et des valeurs
  cles = list(mon_dict.keys())
  vals = list(mon_dict.values())
  
  # Fusion (Python 3.9+)
  d2 = {"pays": "France"}
  fusion = mon_dict | d2
  

1. Lecture & écriture

# Écriture (mode "w" écrase)
  with open("notes.txt", "w", encoding="utf-8") as f:
      f.write("Ligne 1\nLigne 2\n")
  
  # Lecture complète
  with open("notes.txt", "r", encoding="utf-8") as f:
      contenu = f.read()
      print(contenu)
  
  # Lecture ligne par ligne
  with open("notes.txt", "r", encoding="utf-8") as f:
      for ligne in f:
          print(ligne.strip())
  

2. Autres modes d'ouverture

• "a" → append : ajoute sans écraser
• "x" → crée le fichier, échoue s'il existe
• "b" → mode binaire (ex. "rb", "wb")
• "+" → lecture et écriture simultanées (ex. "r+")

Importer un module

import math
  from datetime import datetime
  
  print(math.sqrt(16))      # 4.0
  print(datetime.now())     # date et heure courantes

Créer son propre module

Créez un fichier mon_module.py :

# mon_module.py
  def saluer(nom):
      return f"Bonjour, {nom} !"

Puis dans votre script :

from mon_module import saluer
  print(saluer("Valentin"))

PIP (gestionnaire de paquets)

# Installer un paquet
  pip install requests
  
  # Lister les paquets installés
  pip list
  
  # Mettre à jour un paquet
  pip install --upgrade requests

Définition d'une classe

class Personne:
      def __init__(self, nom, age):
          self.nom = nom
          self.age = age
  
      def se_presenter(self):
          return f"Je m'appelle {self.nom} et j'ai {self.age} ans."
  
  # Utilisation
  p = Personne("Valentin", 23)
  print(p.se_presenter())

Héritage

class Étudiant(Personne):
      def __init__(self, nom, age, ecole):
          super().__init__(nom, age)
          self.ecole = ecole
  
      def se_presenter(self):
          base = super().se_presenter()
          return base + f" Je suis à {self.ecole}."