Cheat Sheet Python 3 : Référence rapide pour des domaines spécifiques (web, data science, etc.)

print("Hello World!")  # Affichage simple
print(f"Variable: {variable}")  # f-string (Python 3.6+)
print("a", "b", sep=", ")  # Séparateur personnalisé

x = 10                  # Entier (int)
y = 3.14                # Flottant (float)
nom = "Alice"           # Chaîne (str)
est_vrai = True         # Booléen (bool)
a = None                # Valeur nulle

# Arithmétiques
5 + 3   # Addition
5 - 3   # Soustraction
5 * 3   # Multiplication
5 / 3   # Division (float)
5 // 3  # Division entière
5 % 3   # Modulo
5 ** 3  # Puissance

# Comparaison
a == b  # Égalité
a != b  # Différence
a < b   # Inférieur
a > b   # Supérieur
a <= b  # Inférieur ou égal
a >= b  # Supérieur ou égal

# Logiques
True and False  # ET
True or False   # OU
not True        # NON

# Condition if
if x > 0:
    print("Positif")
elif x < 0:
    print("Négatif")
else:
    print("Zéro")

# Boucle for
for i in range(5):      # 0 à 4
    print(i)

for item in liste:
    print(item)

# Boucle while
while x > 0:
    print(x)
    x -= 1

ma_liste = [1, 2, 3]
ma_liste[0]             # Accès (1)
ma_liste[-1]            # Dernier élément (3)
ma_liste.append(4)      # Ajout en fin
ma_liste.insert(1, 5)   # Insertion à l'index 1
ma_liste.remove(2)      # Suppression par valeur
ma_liste.pop(0)         # Suppression par index
len(ma_liste)           # Taille
ma_liste.sort()         # Tri
ma_liste.reverse()      # Inversion
[x*2 for x in ma_liste] # List comprehension

mon_tuple = (1, 2, 3)   # Immutable
mon_tuple[0]            # Accès (1)
a, b, c = mon_tuple     # Déballage

mon_dict = {"clé": "valeur", "age": 30}
mon_dict["clé"]         # Accès ("valeur")
mon_dict["nouvelle_clé"] = 42  # Ajout
"clé" in mon_dict       # Vérification (True)
mon_dict.keys()         # Clés
mon_dict.values()       # Valeurs
mon_dict.items()        # Paires clé-valeur
{key: val*2 for key, val in mon_dict.items()}  # Dict comprehension

mon_set = {1, 2, 3}     # Ensemble unique
mon_set.add(4)          # Ajout
mon_set.remove(2)       # Suppression
set1 | set2             # Union
set1 & set2             # Intersection
set1 - set2             # Différence
{x for x in range(5)}   # Set comprehension

def ma_fonction(param1, param2=10):
    """Documentation de la fonction"""
    result = param1 + param2
    return result

# Paramètres positionnels
ma_fonction(1, 2)

# Paramètres nommés
ma_fonction(param2=2, param1=1)

# Nombre variable d'arguments
def fonction_varargs(*args):
    for arg in args:
        print(arg)

# Nombre variable d'arguments nommés
def fonction_kwargs(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

carre = lambda x: x ** 2
sorted(liste, key=lambda x: x[1])  # Tri avec lambda

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

# Lecture
with open("fichier.txt", "r") as f:
    contenu = f.read()          # Tout le contenu
    lignes = f.readlines()      # Liste de lignes
    for ligne in f:             # Lecture ligne par ligne
        print(ligne.strip())

try:
    result = 10 / 0
except ZeroDivisionError:
    print("Division par zéro!")
except Exception as e:
    print(f"Erreur: {e}")
else:
    print("Aucune erreur")
finally:
    print("Exécuté dans tous les cas")

class MaClasse:
    # Variable de classe
    var_classe = 0

    # Constructeur
    def __init__(self, valeur):
        self.valeur = valeur

    # Méthode d'instance
    def afficher(self):
        print(f"Valeur: {self.valeur}")

    # Méthode de classe
    @classmethod
    def methode_classe(cls):
        print(f"Var classe: {cls.var_classe}")

    # Méthode statique
    @staticmethod
    def methode_statique():
        print("Méthode statique")

# Héritage
class Enfant(MaClasse):
    def __init__(self, valeur, extra):
        super().__init__(valeur)
        self.extra = extra

import module
from module import fonction
from module import *
import module as alias
from package.submodule import fonction

# Dans module.py
def fonction_module():
    print("Fonction du module")

# Dans __init__.py (pour les packages)

len(obj)                # Taille
range(start, stop, step)# Génère une séquence
type(obj)               # Type d'objet
isinstance(obj, type)   # Vérification de type
enumerate(iterable)     # Paire index-valeur
zip(iter1, iter2)       # Agrégation d'itérables
sorted(iterable)        # Tri
filter(func, iterable)  # Filtrage
map(func, iterable)     # Application de fonction

# Math
import math
math.sqrt(16)           # Racine carrée
math.pi                 # Constante π

# Dates
from datetime import datetime
now = datetime.now()
now.strftime("%d/%m/%Y %H:%M:%S")

# JSON
import json
json_str = json.dumps({"a": 1})  # Dict → JSON
data = json.loads(json_str)      # JSON → Dict

# Système
import os
os.listdir()            # Liste fichiers
os.path.exists("fichier") # Vérifie existence

# Expressions régulières
import re
re.findall(r"\d+", "a1b22c")  # ['1', '22']

# Générateur simple
def gen():
    yield 1
    yield 2

# Expression de générateur
gen_expr = (x**2 for x in range(5))

# Itérateur personnalisé
class MonIterateur:
    def __iter__(self):
        self.n = 0
        return self

    def __next__(self):
        if self.n < 5:
            self.n += 1
            return self.n
        else:
            raise StopIteration

def mon_decorateur(func):
    def wrapper(*args, **kwargs):
        print("Avant l'appel")
        result = func(*args, **kwargs)
        print("Après l'appel")
        return result
    return wrapper

@mon_decorateur
def ma_fonction():
    print("Fonction décorée")

class MonContexte:
    def __enter__(self):
        print("Entrée")
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        print("Sortie")

with MonContexte() as ctx:
    print("Dans le contexte")

# Threading
import threading
def worker():
    print("Tâche exécutée")
thread = threading.Thread(target=worker)
thread.start()
thread.join()

# Multiprocessing
from multiprocessing import Process
proc = Process(target=worker)
proc.start()
proc.join()

def fonction(param: int) -> str:
    return str(param)