Bootcamp Python10 Jours pour Maîtriser Python & Data Science

# Mon premier programme Python !
print("Hello DIAM!")
print("Bienvenue dans le monde de Python")
print("=" * 40)

# Exécution : python hello.py

nom         = "Alice"    # str
age         = 25        # int
taille      = 1.75      # float
est_etudiant= True      # bool

print(nom)              # Alice
print(type(nom))        # <class 'str'>
print(f"Prénom : {nom}, Âge : {age} ans")

a, b = 10, 3
print(f"{a} + {b} = {a + b}")    # 13
print(f"{a} - {b} = {a - b}")    # 7
print(f"{a} × {b} = {a * b}")    # 30
print(f"{a} / {b} = {a / b}")    # 3.333...
print(f"{a} // {b} = {a // b}")   # 3 (division entière)
print(f"{a} % {b} = {a % b}")    # 1 (reste)
print(f"{a} ^ {b} = {a ** b}")   # 1000 (puissance)

nom = input("Votre nom : ")
print(f"Bonjour {nom} !")

# Convertir en entier directement
age    = int(input("Votre âge : "))
taille = float(input("Taille (m) : "))

texte = "  Python est Génial  "
print(texte.upper())     # "  PYTHON EST GÉNIAL  "
print(texte.lower())     # "  python est génial  "
print(texte.strip())     # "Python est Génial"
print(texte.replace("Génial", "Super"))

# Slicing
mot = "Python"
print(mot[0])      # P
print(mot[-1])     # n
print(mot[0:3])    # Pyt
print(mot[::-1])   # nohtyP

# F-Strings (méthode recommandée)
nom, age = "Alice", 25
print(f"{nom} a {age} ans")
print(f"Pi : {3.14159:.2f}")      # 3.14
print(f"{1000000:,}")            # 1,000,000

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

# Opérateurs logiques : and, or, not
age, permis = 20, True
if age >= 18 and permis:
    print("✓ Vous pouvez conduire")

# Boucle infinie + break
while True:
    rep = input("Continuer ? (o/n) : ")
    if rep.lower() == 'n':
        break
    print("On continue !")

# Continue : sauter à l'itération suivante
n = 0
while n < 10:
    n += 1
    if n % 2 == 0:
        continue      # Saute les pairs
    print(n)          # 1,3,5,7,9

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)

for i in range(10, 0, -1):  # 10,9,...,1
    print(i)

for lettre in "DIAM":        # D I A M
    print(lettre)

# Fonction simple
def dire_bonjour():
    print("Bonjour du club DIAM !")

dire_bonjour()

# Avec paramètre + return
def calculer_carre(nombre):
    """Retourne le carré d'un nombre."""
    return nombre ** 2

print(calculer_carre(5))    # 25

# *args : nombre variable d'arguments
def calculer_somme(*nombres):
    return sum(nombres)

print(calculer_somme(1, 2, 3))         # 6
print(calculer_somme(10, 20, 30, 40))  # 100

# Valeur par défaut
def saluer(nom, message="Bonjour"):
    print(f"{message} {nom} !")

saluer("Alice")             # Bonjour Alice !
saluer("Bob", "Bonsoir")    # Bonsoir Bob !

carre    = lambda x: x ** 2
addition = lambda a, b: a + b
print(carre(5))         # 25

nombres = [1, 2, 3, 4, 5]
carres  = list(map(lambda x: x**2, nombres))
print(carres)            # [1, 4, 9, 16, 25]

pairs   = list(filter(lambda x: x%2==0, nombres))
print(pairs)             # [2, 4]

fruits = ["pomme", "banane", "orange"]

fruits.append("kiwi")        # Ajouter à la fin
fruits.insert(1, "mangue")   # Insérer à l'index 1
fruits.remove("banane")     # Supprimer par valeur
dernier = fruits.pop()      # Supprimer + retourner le dernier

fruits.sort()               # Tri croissant
print(len(fruits))           # Longueur
print("pomme" in fruits)    # True/False
print(sum([1,2,3]))          # 6
print(max([10,5,8]))         # 10

n = [0,1,2,3,4,5,6,7,8,9]
print(n[2:7])    # [2, 3, 4, 5, 6]
print(n[:5])     # [0, 1, 2, 3, 4]
print(n[::2])    # [0, 2, 4, 6, 8]
print(n[::-1])   # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
print(n[-3:])    # [7, 8, 9]

# List Comprehension
carres = [x**2 for x in range(5)]           # [0,1,4,9,16]
pairs  = [x for x in range(10) if x%2==0]  # [0,2,4,6,8]
majusc = [m.upper() for m in ["diam", "ia"]] # ['DIAM','IA']

# Unpacking
coord = (10, 20)
x, y  = coord

person = ("Alice", 25, "Libreville")
nom, age, ville = person

# Extended unpacking
premier, *milieu, dernier = (1, 2, 3, 4, 5)

# Échange pythonique (sans variable temp)
a, b = 5, 10
a, b = b, a   # Magie Python !
print(a, b)    # 10 5

etudiant = {
    "nom"    : "Dupont",
    "age"    : 22,
    "notes"  : [15, 18, 16]
}

print(etudiant["nom"])
print(etudiant.get("email", "N/A"))  # N/A (pas d'erreur)

# Parcourir les paires
for cle, val in etudiant.items():
    print(f"{cle} : {val}")

# Dict comprehension
carres = {x: x**2 for x in range(6)}
# {0:0, 1:1, 2:4, 3:9, 4:16, 5:25}

# Filtrer avec comprehension
notes = {"Alice":15, "Bob":8, "Charlie":18}
admis = {n: note for n, note in notes.items() if note >= 10}

A = {1,2,3,4,5}
B = {4,5,6,7,8}

print(A | B)  # Union     → {1,2,3,4,5,6,7,8}
print(A & B)  # Intersection → {4, 5}
print(A - B)  # Différence → {1, 2, 3}
print(A ^ B)  # Diff. symétrique → {1,2,3,6,7,8}

# Dédoublonnage automatique
liste  = [1,2,2,3,1]
unique = list(set(liste))  # [1, 2, 3]

# Écrire dans un fichier
with open("output.txt", "w", encoding="utf-8") as f:
    f.write("Première ligne\n")
    f.write("Deuxième ligne\n")

# Lire tout le contenu
with open("output.txt", "r", encoding="utf-8") as f:
    contenu = f.read()
    print(contenu)

# Lire ligne par ligne
with open("output.txt", "r", encoding="utf-8") as f:
    for ligne in f:
        print(ligne.strip())  # strip() enlève le \n

# Ajouter à la fin (append)
with open("output.txt", "a", encoding="utf-8") as f:
    f.write("Ligne ajoutée\n")

# Modes : "r" lecture, "w" écriture (écrase), "a" ajout

import csv

# Écrire un CSV
with open("etudiants.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.writer(f)
    writer.writerow(["Nom", "Âge", "Ville"])
    writer.writerow(["Alice", 25, "Libreville"])

# Lire avec DictReader (plus pratique)
with open("etudiants.csv", "r", encoding="utf-8") as f:
    reader = csv.DictReader(f)
    for ligne in reader:
        print(f"{ligne['Nom']} a {ligne['Âge']} ans")

import json

donnees = {"nom": "Alice", "age": 25, "notes": [15, 18]}

# Écrire JSON
with open("data.json", "w", encoding="utf-8") as f:
    json.dump(donnees, f, indent=4, ensure_ascii=False)

# Lire JSON
with open("data.json", "r", encoding="utf-8") as f:
    data = json.load(f)
    print(data["nom"])  # Alice

try:
    nombre = int(input("Entrez un nombre : "))
    resultat = 10 / nombre
except ValueError:
    print("❌ Entrez un nombre valide")
except ZeroDivisionError:
    print("❌ Division par zéro impossible")
else:
    print(f"Résultat : {resultat}")  # Si aucune erreur
finally:
    print("Nettoyage effectué")  # Toujours exécuté

# Lever une exception
def verifier_age(age):
    if age < 0:
        raise ValueError("L'âge ne peut pas être négatif")

from pathlib import Path

print(Path.cwd())              # Répertoire actuel

fichier = Path("data") / "notes.txt"
print(fichier.exists())        # True/False
print(fichier.is_file())       # True/False

# Créer un dossier
Path("mon_dossier").mkdir(exist_ok=True)

# Lire/Écrire directement
Path("test.txt").write_text("Contenu", encoding="utf-8")
contenu = Path("test.txt").read_text(encoding="utf-8")

# Lister les .txt du répertoire
for f in Path(".").rglob("*.txt"):
    print(f.name)

class Personne:
    """Représente une personne."""

    def __init__(self, nom, age):
        self.nom = nom   # Attribut d'instance
        self.age = age

    def se_presenter(self):
        print(f"Je m'appelle {self.nom}, j'ai {self.age} ans")

    def __str__(self):
        return f"Personne('{self.nom}', {self.age})"

# Création d'instances
p1 = Personne("Alice", 25)
p2 = Personne("Bob", 30)

p1.se_presenter()  # Je m'appelle Alice, j'ai 25 ans
print(p1)          # Appelle __str__

class CompteBancaire:
    def __init__(self, titulaire, solde=0):
        self.titulaire = titulaire   # Public
        self._solde    = solde       # Protected

    @property
    def solde(self):           # Getter
        return self._solde

    @solde.setter
    def solde(self, valeur):    # Setter avec validation
        if valeur >= 0:
            self._solde = valeur
        else:
            raise ValueError("Solde ne peut pas être négatif")

    def deposer(self, montant):
        if montant > 0:
            self._solde += montant
            print(f"✓ {montant} FCFA déposés")

class Animal:
    def __init__(self, nom, age):
        self.nom = nom
        self.age = age
    def faire_bruit(self):
        print("...")

class Chien(Animal):    # Héritage
    def __init__(self, nom, age, race):
        super().__init__(nom, age)  # Appel parent
        self.race = race
    def faire_bruit(self):         # Override
        print(f"{self.nom} : Wouf !")

# Polymorphisme
animaux = [Chien("Rex", 3, "Berger"), Animal("Chat", 2)]
for a in animaux:
    a.faire_bruit()   # Comportement différent selon la classe

# Importations
import math
import math as m
from math import sqrt, pi
from datetime import datetime, timedelta
import random

print(math.pi)                       # 3.14159...
print(sqrt(25))                      # 5.0

maintenant = datetime.now()
print(maintenant.strftime("%d/%m/%Y"))

print(random.randint(1, 100))        # Entier aléatoire
print(random.choice(["A", "B", "C"])) # Choix aléatoire

# Créer son module : sauvegarder dans utilitaires.py
# Puis l'utiliser : import utilitaires
# Le bloc if __name__ == "__main__": évite l'exécution à l'import

import numpy as np

# Créer des arrays
arr     = np.array([1, 2, 3, 4, 5])
zeros   = np.zeros((3, 4))       # Matrice 3x4 de zéros
plage   = np.arange(0, 10, 2)    # [0, 2, 4, 6, 8]
linesp  = np.linspace(0, 1, 5)   # [0., 0.25, 0.5, 0.75, 1.]
aleat   = np.random.randint(1, 101, 20)

# Opérations vectorielles (sans boucle !)
print(arr + 10)     # [11 12 13 14 15]
print(arr * 2)      # [2  4  6  8  10]
print(arr ** 2)     # [1  4  9  16  25]

# Statistiques
print(np.mean(arr))     # 3.0
print(np.std(arr))      # Écart-type
print(np.median(arr))  # 3.0

# Indexation booléenne
print(arr[arr > 3])    # [4 5]
arr[arr > 3] = 0        # Modifier en place

import pandas as pd
import numpy as np

# Créer un DataFrame
data = {
    'nom'    : ['Alice', 'Bob', 'Charlie'],
    'age'    : [25, 30, 22],
    'salaire': [500000, 750000, 450000]
}
df = pd.DataFrame(data)

print(df.info())        # Infos générales
print(df.describe())   # Statistiques
print(df.head(2))       # 2 premières lignes
print(df.shape)         # (3, 3)

# Sélection
print(df['nom'])           # Colonne
print(df.loc[0, 'nom'])    # Cellule par label
print(df.iloc[0, 1])        # Cellule par position

# Filtrage
print(df[df['age'] > 25])  # Lignes où age > 25
print(df[df['salaire'].isin([500000, 750000])])

# Ajouter des colonnes calculées
df['age_dans_5_ans'] = df['age'] + 5
df['categorie']    = df['salaire'].apply(
    lambda s: 'Senior' if s > 600000 else 'Junior'
)

# Groupby
print(df.groupby('ville')['salaire'].mean())
print(df.groupby('ville').agg({
    'salaire': ['mean', 'sum', 'count'],
    'age': 'mean'
}))

# Valeurs manquantes
print(df.isnull().sum())          # Nb de NaN par colonne
df['age'] = df['age'].fillna(df['age'].mean())
df = df.dropna()                  # Supprimer lignes avec NaN

# Lire / Écrire fichiers
df = pd.read_csv('donnees.csv', encoding='utf-8')
df.to_csv('sortie.csv', index=False)
df.to_json('sortie.json', orient='records', indent=2)