1.Tutorials¶

Python Tutorial¶

Commande python
Si "Py Launcher" installé: py
Arguments peuvent être lus avec module sys: sys.argv[indice]
Fichiers sources encodés en UTF-8
any non-zero integer value is true

VS Code Getting Started¶

TODO pour chaque projet car sinon c'est galere, VS Code ne retrouve pas le venv:
1. Ne pas utiliser "uv" car pas 100% compatible avec VSCode, de plus il requiert l'installation de Rust + VS Build tools qui prennent 7GB...
2. Le terminal VSCode par défaut doit être Command car si c'est Powershell ça ne marche pas terrible terrible...
3. Créer le rep
4. Dans le rep créer un venv: py -m venv .venv
5. Ouvrir le rep avec VS Code:
  - Status barre en ouvrant un fichier py doit afficher la présence du venv
  - Le terminal intégré pip --version doit afficher la version de pip avec son chemin vers le venv
6. S'assurer que Terminal par défaut VSCode = Command & qu'il autoload le venv s'il en détecte un !
Config:
Install the Python extension (VS Code Marketplace)
Install an interpreter (from Python.org)
- Check the console: py -3 --version
Choisir la bonne version de l'interpreteur Python:
- Ctrl+Shift+P
- Python: Select Interpreter
Fichiers de config dans ./.vscode:
- settings.json
  - python.pythonPath mis à jour lors de la sélection de l'interpreteur
- launch.json
  - Config for the run/debug
Créer un environement virtuel:
- Cmd: py -m venv .venv
- Popup "utiliser pour le workspace": oui
- L'activer: .venv\Scripts\Activate.bat
Choisir l'interpreteur Python de cet env
Travailler sur le source + install package
- Le désactiver si plus besoin
Run:
Bouton "Play" en haut à gauche du source
F5 pour debug
- Même fonctionnement que pour les autres languages
F5: Start debug
Maj+F5: Stop debug
F9: Set breakpoint
F10: run
F11: Go into
Shift+F11: go outside
Ctrl+F5
Utiliser Logpoint plutôt que Print pour tracker la valeur des variables
- F9 / Breakpoint
- Edit > Logpoint

Decorator¶

References:
- Real Python / Primer on Python Decorator
- Python.org / PEP-0318
Decorators wrap a function, modifying its behavior
- Consiste à encapsuler la fonction de base en ajoutant un comportement mais sans changer son nom
- Revient à écrire base_func = decorate(base_func), decorate renvoi une fonction qui wrappe base_func
Le decorator est une fonction ou une classe:
- Pas besoin de passer explicitement la fonction a décorer: le passage est implicite
Besoin de specifier liste args variable dans le wrapper qui override la référence initiale autrement le passage d'argument n'est pas possible (*args, **kwargs) et appeler la fonction cible avec ces arguments:
- *args:
  - Liste variable d'arguments
  - S'applique uniquement pour les arguments non-nommés
  - Produit une variable de type Liste à utiliser dans la fonction
- **kwargs:
  - Liste variable d'arguments
  - S'applique uniquement pour les arguments nommés
  - Func(nom="test") => Le nom de l'arg (nom) devient la clé et valeur de l'arg (test) devient la valeur
    - Le tout devient une entrée dans le dictionnaire
  - Produit une variable de type Dictionnaire à utiliser dans la fonction
  - KWARGS = Key Word Args ;)
  - Le wrapper doit retourner le call de la fonction à décorer autrement l'override par décorateur ne renvoit rien
  - Le wrapper doit être décoré avec @functools.wraps afin de lui recopier les valeurs d'info provenant de la fonction de base (__name__, __doc__ etc)
Decorator simple:

# Definition - doc.py
import functools

# Decorator via une fonction
def decorator_name(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):       # définit un nombre variable d'arguments, nommés ou non
        return func(*args, **kwargs)    # depackte les listes et dictionnaires d'arguments en suite de variable
                                        # pour être transparent vis-à-vis de la fonction lors de son appel
    return wrapper

Decorator avec arguments:

import functools

# Decorator avec arguments - besoin d'avoir un niveau d'imbrication supplémentaire
# car l'argument référence à la fonction à décorer est passé implicitement
def decorator_args(arg1="def value", …):
    def wrapper_top(func):
        @functools.wrap(func)
        def wrapper_bottom(*args, **kwargs):
            return func(*args, **kwargs)
        return wrapper_bottom
    return wrapper_top

Decorator via une classe:

# besoin de configurer le constructeur et la fonction __call__
# __call__ est appelée lorsqu'on invoque l'instance de l'objet en tant que fonction
# o = ClassDecorator() puis o() ==> appelle la fonction __call__ de l'objet
class ClassDecorator:
    def __init__(self, func):
        functools.update_wrapper(self, func) //décore la classe avec les infos de la fonction source
        self.func = func

    def __call__(self, *args, **kwargs):
        return self.func(*args, **kwargs)

Utilisation d'un Decorator:

from deco import decorator_name

@decorator_name
def func_name():
    pass


@deforator_args(key=value)
def func_name_2():
    pass


# @ClassDecorator est équivalent à:
# _ = ClassDecorator() => appel du constructeur de la classe
# _() => appel fonction __call__ de l'objet
@ClassDecorator
def func_name_3():
    pass