Mémo Python

# Variables (typage dynamique)
name = "Alice"        # str
age = 25               # int
price = 19.99          # float
is_active = True       # bool
nothing = None         # NoneType

# Type hints (Python 3.5+)
name: str = "Alice"
age: int = 25
prices: list[float] = [9.99, 19.99]
user: dict[str, int] = {"age": 25# Vérification de type
type(name)             # <class 'str'>
isinstance(age, int)  # True
isinstance(age, (int, float))  # True

# Conversion (casting)
str(42)                # "42"
int("42")              # 42
float("3.14")          # 3.14
bool(0)                # False
list("abc")            # ['a', 'b', 'c']

# Opérateurs arithmétiques
5 + 3    # 8  (addition)
5 - 3    # 2  (soustraction)
5 * 3    # 15 (multiplication)
5 / 3    # 1.666... (division)
5 // 3   # 1  (division entière)
5 % 3    # 2  (modulo)
5 ** 3   # 125 (puissance)

# Opérateurs de comparaison
5 == 5   # True (égalité)
5 != 3   # True (différent)
5 > 3    # True (supérieur)
5 >= 5   # True (supérieur ou égal)

# Opérateurs logiques
True and False  # False
True or False   # True
not True        # False

# Assigner ET utiliser dans une expression
# Avant :
n = len(data)
if n > 10:
    print(f"Trop long: {n}")

# Avec Walrus Operator :
if (n := len(data)) > 10:
    print(f"Trop long: {n}")

# Utile dans les while
while (line := file.readline()):
    process(line)

# Utile dans les list comprehensions
filtered = [y for x in data if (y := compute(x)) > 0]

# Fonction simple
def greet(name):
    return f"Hello {name}!"

# Valeur par défaut
def power(base, exp=2):
    return base ** exp

# Type hints
def add(a: int, b: int) -> int:
    return a + b

# *args et **kwargs
def func(*args, **kwargs):
    print(args)    # tuple
    print(kwargs)  # dict

# Lambda
double = lambda x: x * 2

            

                
📦 *ARGS et **KWARGS Visualizer
                

                    Testez vos arguments (ex: 1, 2, a=3, b="test")
                
                
                

                    
                    Visualiser
                

                

                    

                        
*args (Tuple)
                        
()
                        
Arguments positionnels
                    
                    

                        
**kwargs (Dict)
                        
{}
                        
Arguments nommés
                    
                
            

            

                

                     
Le Pattern Décorateur
                     
                
                

                    
Décorateur
                    
# Décorateur (Wrapper)
def decorator(func):
    def wrapper(*args):
        print("LOG: Before call")
        result = func(*args)
        print("LOG: After call")
        return result
    return wrapper

@decorator
def say_hello(name):
    print(f"Hello {name}!")
            
        

        

            
Résultat attendu
            
greet("Python") → "Hello Python!"
                power(2, 8) → 256
                double(5) → 10
        
        

from abc import ABC, abstractmethod
import random

# Classe Abstraite (ne peut être instanciée)
class Personnage(ABC):
    def __init__(self, nom, pv):
        self.nom = nom
        self.pv = pv
    
    # Méthode Abstraite (doit être implémentée par les enfants)
    @abstractmethod
    def attaquer(self):
        pass

    # Méthode Statique (utilitaire, pas de self)
    @staticmethod
    def roll_dice(sides=20):
        return random.randint(1, sides)

class Guerrier(Personnage):
    def attaquer(self):
        dmg = Personnage.roll_dice(6) + 2
        print(f"{self.nom} frappe ({dmg} dmg) !")

class Mage(Personnage):
    def attaquer(self):
        dmg = Personnage.roll_dice(10)
        print(f"{self.nom} lance un sort ({dmg} dmg) !")

# p = Personnage("Test")  # ERREUR: TypeError (Abstract class)

# Polymorphisme
groupe = [Guerrier("Conan", 150), Mage("Gandalf", 80)]
for h in groupe:
    h.attaquer()  # Chaque classe a sa propre version

# Structure Complète
try:
    val = int(user_input)
    res = 100 / val
except ValueError:
    print("Ce n'est pas un nombre !")
except ZeroDivisionError:
    print("Division par zéro interdite !")
except Exception as e:
    print(f"Erreur inconnue : {e}")
else:
    print(f"Résultat : {res}")
finally:
    print("Fin de l'opération.")

# Lecture (with = fermeture auto)
with open("file.txt", "r", encoding="utf-8") as f:
    content = f.read()        # tout
    lines = f.readlines()     # liste
    for line in f:            # itérer
        print(line.strip())

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

# Append
with open("file.txt", "a") as f:
    f.write("New line\n")

# JSON
import json

# Sauvegarder
with open("data.json", "w") as f:
    json.dump(data, f, indent=2)

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

# Pathlib (moderne)
from pathlib import Path
p = Path("folder/file.txt")
p.exists()
p.read_text()
p.write_text("content")

import csv
import pickle
# import yaml  # pip install pyyaml

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

# Pickle (Sérialisation binaire objets Python)
data = {"temp": 24.5, "hum": 60}
with open("data.pkl", "wb") as f:
    pickle.dump(data, f)

with open("data.pkl", "rb") as f:
    loaded = pickle.load(f)

# Import standard
import os
import sys
import json
from datetime import datetime, timedelta
from pathlib import Path
from typing import List, Dict, Optional

# Alias
import numpy as np
import pandas as pd

# Depuis un module local
from mypackage.module import function
from . import sibling  # relatif

# Virtual environment
python -m venv venv
source venv/bin/activate  # Linux/Mac
venv\Scripts\activate     # Windows

# Pip
pip install package
pip install -r requirements.txt
pip freeze > requirements.txt

# Exécution
python script.py
python -m module

text = "Python"

text[0]      # "P" (Premier)
text[-1]     # "n" (Dernier)
text[0:2]    # "Py" (Stop exclus)
text[2:]     # "thon" (Jusqu'à la fin)
text[:3]     # "Pyt" (Depuis le début)
text[::2]    # "Pto" (Pas de 2)
text[::-1]   # "nohtyP" (Inverse)

s = "  hello world, python is fun  "

# Nettoyage et Normalisation
clean = s.strip().upper()
# "HELLO WORLD, PYTHON IS FUN"

# Extraction de mots
mots = clean.replace(",", "").split(" ")
# ['HELLO', 'WORLD', 'PYTHON', 'IS', 'FUN']

# Reconstruction
kebab = "-".join(mots)
# "HELLO-WORLD-PYTHON-IS-FUN"

# Validation
if kebab.startswith("HELLO"):
    print("Salutations détectées !")

# Formatage avancé
print("Id".center(10, "="))   # "====Id===="
print("42".zfill(5))        # "00042"

import re

# Patterns de base
pattern = r"\d+"          # chiffres
pattern = r"[a-zA-Z]+"    # lettres
pattern = r"\w+"          # alphanumérique
pattern = r"\s+"          # espaces

# Méthodes principales
re.match(pattern, text)    # Début chaîne UNIQUEMENT
re.search(pattern, text)   # Cherche PARTOUT (1ère occ.)
re.findall(pattern, text)  # Liste de toutes les occurrences
re.finditer(pattern, text) # itérateur
re.sub(pattern, repl, text) # remplacer
re.split(pattern, text)   # découper

# Exemple: extraire emails
text = "Contact: alice@mail.com, bob@test.fr"
emails = re.findall(r"[\w.]+@[\w.]+\.\w+", text)
# ['alice@mail.com', 'bob@test.fr']

# Groupes de capture
m = re.search(r"(\d{2})/(\d{2})/(\d{4})", "Date: 25/12/2025")
m.group(0)    # "25/12/2025" (tout)
m.group(1)    # "25" (jour)
m.groups()   # ('25', '12', '2025')

# Groupes nommés
pattern = r"(?P<day>\d{2})/(?P<month>\d{2})/(?P<year>\d{4})"
m = re.search(pattern, "25/12/2025")
m.group("year")  # "2025"

# Compilation (performance)
regex = re.compile(r"\d+")
regex.findall(text)

# Fonction générateur
def countdown(n):
    while n > 0:
        yield n
        n -= 1

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

# Generator expression
squares = (x**2 for x in range(1000000))  # économe en mémoire

# Générateur infini
def infinite_counter():
    n = 0
    while True:
        yield n
        n += 1

# yield from (délégation)
def flatten(nested):
    for item in nested:
        if isinstance(item, list):
            yield from flatten(item)
        else:
            yield item

# itertools
from itertools import count, cycle, repeat, chain, islice

count(10)           # 10, 11, 12, ...
cycle([1,2,3])      # 1, 2, 3, 1, 2, 3, ...
repeat("A", 5)      # A, A, A, A, A
chain([1], [2,3])   # 1, 2, 3
islice(gen, 10)     # 10 premiers éléments

# Interaction (Coroutines avancées)
def grep(pattern):
    print(f"Looking for {pattern}")
    while True:
        line = (yield)
        if pattern in line:
            print(line)

g = grep("python")
next(g)        # Amorcer
g.send("Hello python")  # Envoie valeur au yield
g.throw(RuntimeError, "Stop") 
g.close()

# Exécuter les tests
pytest                     # tous les tests
pytest test_file.py        # un fichier
pytest -v                  # verbose
pytest -k "test_add"       # par nom
pytest --cov=mypackage     # avec couverture

> plt.plot(x, y) # Output generated successfully