Bases Python

# Nombres
age = 25                    # int
prix = 19.99               # float
complexe = 3 + 4j          # complex

# Chaînes de caractères
nom = "Nicolas"
prenom = 'Lema'
multi = """Texte sur
plusieurs lignes"""

# Booléens
actif = True
termine = False

# None (valeur nulle)
resultat = None

# Afficher le type
print(type(age))           # 

# String vers nombre
age = int("25")
prix = float("19.99")

# Nombre vers string
texte = str(42)

# String vers booléen
bool("True")  # True (toute string non vide = True)
bool("")      # False

# Liste vers tuple et vice-versa
liste = [1, 2, 3]
tuple_val = tuple(liste)
nouvelle_liste = list(tuple_val)

# Création
fruits = ["pomme", "banane", "orange"]
nombres = [1, 2, 3, 4, 5]
mixte = [1, "deux", 3.0, True]

# Accès par index (commence à 0)
premier = fruits[0]         # "pomme"
dernier = fruits[-1]        # "orange"

# Slicing
premiers = fruits[0:2]      # ["pomme", "banane"]
derniers = fruits[1:]       # ["banane", "orange"]

# Modification
fruits[0] = "fraise"
fruits.append("kiwi")       # Ajouter à la fin
fruits.insert(1, "mangue")  # Insérer à l'index 1
fruits.remove("banane")     # Supprimer par valeur
element = fruits.pop()      # Retirer et retourner le dernier
fruits.clear()              # Vider la liste

# Opérations
len(fruits)                 # Longueur
"pomme" in fruits          # Vérifier présence
fruits.sort()              # Trier sur place
sorted(fruits)             # Retourner nouvelle liste triée
fruits.reverse()           # Inverser l'ordre

# Immuable (non modifiable)
coordonnees = (10, 20)
personne = ("Nicolas", 25, "Lausanne")

# Accès
x = coordonnees[0]
nom, age, ville = personne  # Unpacking

# Tuple d'un élément (virgule obligatoire)
singleton = (42,)

# Création
personne = {
    "nom": "Lema",
    "prenom": "Nicolas",
    "age": 25,
    "ville": "Lausanne"
}

# Accès
nom = personne["nom"]
age = personne.get("age")           # Plus sûr (retourne None si absent)
age = personne.get("age", 0)        # Avec valeur par défaut

# Modification
personne["age"] = 26
personne["email"] = "n@example.com" # Ajouter nouvelle clé

# Suppression
del personne["ville"]
email = personne.pop("email")       # Retirer et retourner

# Itération
for cle in personne:
    print(cle, personne[cle])

for cle, valeur in personne.items():
    print(f"{cle}: {valeur}")

# Méthodes utiles
personne.keys()                     # Toutes les clés
personne.values()                   # Toutes les valeurs
personne.items()                    # Paires (clé, valeur)

# Collection non ordonnée sans doublons
nombres = {1, 2, 3, 4, 5}
unique = set([1, 2, 2, 3, 3, 3])    # {1, 2, 3}

# Opérations
nombres.add(6)
nombres.remove(3)
nombres.discard(10)                  # Ne lève pas d'erreur si absent

# Opérations ensemblistes
a = {1, 2, 3, 4}
b = {3, 4, 5, 6}

union = a | b                        # {1, 2, 3, 4, 5, 6}
intersection = a & b                 # {3, 4}
difference = a - b                   # {1, 2}
diff_sym = a ^ b                     # {1, 2, 5, 6}

# If simple
age = 18
if age >= 18:
    print("Majeur")

# If/else
if age >= 18:
    print("Majeur")
else:
    print("Mineur")

# If/elif/else
note = 85
if note >= 90:
    print("Excellent")
elif note >= 70:
    print("Bien")
elif note >= 50:
    print("Passable")
else:
    print("Insuffisant")

# Opérateur ternaire
statut = "Majeur" if age >= 18 else "Mineur"

# Opérateurs de comparaison
x == y  # Égal
x != y  # Différent
x > y   # Supérieur
x >= y  # Supérieur ou égal
x < y   # Inférieur
x <= y  # Inférieur ou égal

# Opérateurs logiques
if age >= 18 and pays == "Suisse":
    print("Peut voter en Suisse")

if jour == "samedi" or jour == "dimanche":
    print("Weekend")

if not termine:
    print("En cours")

# Itérer sur une liste
fruits = ["pomme", "banane", "orange"]
for fruit in fruits:
    print(fruit)

# Avec index
for i, fruit in enumerate(fruits):
    print(f"{i}: {fruit}")

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

for i in range(2, 10):      # 2 à 9
    print(i)

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

# Itérer sur dictionnaire
personne = {"nom": "Nicolas", "age": 25}
for cle, valeur in personne.items():
    print(f"{cle}: {valeur}")

# List comprehension
carres = [x**2 for x in range(10)]
pairs = [x for x in range(20) if x % 2 == 0]

# While simple
compteur = 0
while compteur < 5:
    print(compteur)
    compteur += 1

# While avec condition complexe
reponse = ""
while reponse.lower() != "oui":
    reponse = input("Continuer ? (oui/non) ")

# Break et continue
for i in range(10):
    if i == 3:
        continue  # Passer à l'itération suivante
    if i == 7:
        break     # Sortir de la boucle
    print(i)

# Fonction simple
def saluer():
    print("Bonjour!")

saluer()

# Avec paramètres
def saluer_personne(nom):
    print(f"Bonjour {nom}!")

saluer_personne("Nicolas")

# Avec valeur de retour
def additionner(a, b):
    return a + b

resultat = additionner(5, 3)  # 8

# Paramètres par défaut
def saluer_avec_titre(nom, titre="M."):
    return f"Bonjour {titre} {nom}"

print(saluer_avec_titre("Dupont"))           # Bonjour M. Dupont
print(saluer_avec_titre("Martin", "Mme"))    # Bonjour Mme Martin

# Nombre variable d'arguments (*args)
def somme(*nombres):
    total = 0
    for n in nombres:
        total += n
    return total

print(somme(1, 2, 3))         # 6
print(somme(1, 2, 3, 4, 5))   # 15

# Arguments nommés variables (**kwargs)
def afficher_info(**infos):
    for cle, valeur in infos.items():
        print(f"{cle}: {valeur}")

afficher_info(nom="Nicolas", age=25, ville="Lausanne")

# Fonction anonyme courte
carre = lambda x: x**2
print(carre(5))  # 25

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

# Avec filter
pairs = list(filter(lambda x: x % 2 == 0, nombres))

# Trier avec key
personnes = [
    {"nom": "Alice", "age": 30},
    {"nom": "Bob", "age": 25},
    {"nom": "Charlie", "age": 35}
]
tries = sorted(personnes, key=lambda p: p["age"])

# Définition de classe
class Personne:
    # Constructeur
    def __init__(self, nom, prenom, age):
        self.nom = nom
        self.prenom = prenom
        self.age = age
    
    # Méthode
    def se_presenter(self):
        return f"Je m'appelle {self.prenom} {self.nom}, j'ai {self.age} ans"
    
    # Méthode qui modifie l'état
    def vieillir(self):
        self.age += 1

# Création d'instances
p1 = Personne("Lema", "Nicolas", 25)
p2 = Personne("Martin", "Sophie", 30)

# Utilisation
print(p1.se_presenter())
p1.vieillir()
print(p1.age)  # 26

# Classe de base
class Personne:
    def __init__(self, nom, prenom):
        self.nom = nom
        self.prenom = prenom
    
    def se_presenter(self):
        return f"Je suis {self.prenom} {self.nom}"

# Classe dérivée
class Etudiant(Personne):
    def __init__(self, nom, prenom, numero_etudiant):
        super().__init__(nom, prenom)  # Appel constructeur parent
        self.numero_etudiant = numero_etudiant
    
    # Surcharge de méthode
    def se_presenter(self):
        base = super().se_presenter()
        return f"{base}, étudiant n°{self.numero_etudiant}"

etudiant = Etudiant("Lema", "Nicolas", "ES2024001")
print(etudiant.se_presenter())

class CompteBancaire:
    def __init__(self, titulaire, solde_initial=0):
        self.titulaire = titulaire
        self._solde = solde_initial  # Attribut "privé" par convention
    
    # Property (getter)
    @property
    def solde(self):
        return self._solde
    
    # Setter
    @solde.setter
    def solde(self, montant):
        if montant < 0:
            raise ValueError("Le solde ne peut pas être négatif")
        self._solde = montant
    
    # Méthodes
    def deposer(self, montant):
        if montant > 0:
            self._solde += montant
    
    def retirer(self, montant):
        if 0 < montant <= self._solde:
            self._solde -= montant
        else:
            raise ValueError("Montant invalide ou solde insuffisant")
    
    # Méthode spéciale pour représentation
    def __str__(self):
        return f"Compte de {self.titulaire}: {self._solde} CHF"
    
    # Méthode spéciale pour comparaison
    def __eq__(self, other):
        return self._solde == other._solde

compte = CompteBancaire("Nicolas", 1000)
compte.deposer(500)
print(compte.solde)  # 1500
print(compte)        # Compte de Nicolas: 1500 CHF

# Try/except basique
try:
    resultat = 10 / 0
except ZeroDivisionError:
    print("Division par zéro impossible")

# Plusieurs exceptions
try:
    nombre = int(input("Entrez un nombre: "))
    resultat = 100 / nombre
except ValueError:
    print("Veuillez entrer un nombre valide")
except ZeroDivisionError:
    print("Le nombre ne peut pas être zéro")

# Capturer toutes les exceptions
try:
    # Code risqué
    pass
except Exception as e:
    print(f"Erreur: {e}")

# Else et finally
try:
    fichier = open("data.txt", "r")
    contenu = fichier.read()
except FileNotFoundError:
    print("Fichier introuvable")
else:
    print("Fichier lu avec succès")
finally:
    fichier.close()  # Toujours exécuté

# With statement (context manager)
try:
    with open("data.txt", "r") as f:
        contenu = f.read()
        # Le fichier est fermé automatiquement
except FileNotFoundError:
    print("Fichier introuvable")

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

# Import module entier
import math
print(math.pi)
print(math.sqrt(16))

# Import avec alias
import pandas as pd
df = pd.DataFrame()

# Import spécifique
from math import pi, sqrt
print(pi)
print(sqrt(16))

# Import tout (à éviter)
from math import *

# Modules standard utiles
import os           # Système de fichiers
import sys          # Système Python
import datetime     # Dates et heures
import json         # JSON
import random       # Nombres aléatoires
import re           # Expressions régulières
import pathlib      # Chemins de fichiers moderne

# Créer son propre module
# Fichier: mon_module.py
def ma_fonction():
    return "Hello"

# Fichier: main.py
import mon_module
print(mon_module.ma_fonction())

# Lire un fichier
with open("fichier.txt", "r", encoding="utf-8") as f:
    contenu = f.read()           # Tout le fichier
    
with open("fichier.txt", "r") as f:
    lignes = f.readlines()       # Liste de lignes
    
with open("fichier.txt", "r") as f:
    for ligne in f:              # Ligne par ligne (économe en mémoire)
        print(ligne.strip())

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

# Ajouter à la fin
with open("fichier.txt", "a") as f:
    f.write("Ligne ajoutée\n")

# Modes d'ouverture
# "r"  - Lecture (défaut)
# "w"  - Écriture (écrase)
# "a"  - Ajout (append)
# "r+" - Lecture et écriture
# "b"  - Mode binaire (ex: "rb", "wb")

# JSON
import json

# Écrire JSON
data = {"nom": "Nicolas", "age": 25}
with open("data.json", "w") as f:
    json.dump(data, f, indent=4)

# Lire JSON
with open("data.json", "r") as f:
    data = json.load(f)

# CSV
import csv

# Écrire CSV
with open("data.csv", "w", newline="") as f:
    writer = csv.writer(f)
    writer.writerow(["Nom", "Age", "Ville"])
    writer.writerow(["Nicolas", 25, "Lausanne"])

# Lire CSV
with open("data.csv", "r") as f:
    reader = csv.reader(f)
    for row in reader:
        print(row)