1. accessibilité
2. “shell” est le comportement par défaut
3. multiplateforme
4. introspection

1. langage de glu
2. spécialisations (calculs, etc.)
3. écriture “pythonique”
   1. “PEP” : Python Enhancement Proposals - proposition d'amélioration de Python
   2. efficacité du bytecode

1. deux concepts-clé d'adoption : “clarté” et arbres syntaxiques abstraits
2. “duck typing”
   1. exemple du “manager context” (“with”)
3. interprétation = expansion
   1. exemple avec le formatage des chaînes
   2. approche des différences entre “chaîne de caractères” (“str”) et séquences de bits (“bytes”)
4. sucre syntaxique et hack de performance
   1. retour “multiple”
   2. étoiles / double étoiles
   3. boucles vs listes en compréhension

1. le GIL (“Global Interpreter Lock”)
2. notions d’interprétation (exécutable)
   1. les étapes
      • analyse syntaxique
      • analyse sémantique
      • compilation en “bycode”)
   2. variable et comptage par références
   3. “multiprocessing” / “subprocess” ; “thread” et “green thread”
3. Python est “lent” s'il est mal utilisé
4. pas que Python… C + TCL

1. impératif
   1. impératif : les opérations à faire [vs] déclaratif : l'état désiré
2. objet
   1. représentation d'un objet en mémoire
   2. méthodes et propriétés
   3. surcharge et classe fondamentale
3. fonctionnel (1958, McCarthy)
   1. est une variante de la programmation déclarative
   2. fonctions de premier niveau
   3. immuabilité et transparence référentielle
   4. lambda

1. impératif ⇒ état global, mutabilité
   1. la séquence d'instructions
   2. l'assignation ou affectation
   3. l'instruction conditionnelle
   4. la boucle
   5. les (em)branchements
2. fonctionnel ⇒ expression locale, immuabilité
   1. pureté
   2. “expressivité”
      1. expressions
      2. valeurs
      3. fonctions (sous-ensembles des valeurs)
   3. inférence (typage des valeurs comme paramètres de fonction)

Nb :

• Python reprend des concepts fondamentaux (frontières floues)
• L'orientation “fonctionnelle” de plus en plus utilisée

1. polymorphisme
   1. “duck typing” jusqu'à la base originale (“object” : méthodes et attributs fondamentaux, indépassables)
   2. héritage
   3. typage d'arguments (hack)
2. portée des variables
   1. création de “fermetures” (“closure”) → lambda
   2. application aux classes (singleton)
   3. surcharge locale (appel d'une variable globale)
3. modules
   1. gestion des espaces de nom
   2. principe de factorisation
   3. chemin de chargement et appel (ex. “globale” dans un module)
4. (simili-)macro et génération (dont documentation)
   1. texte ↔ code (“repr”, “compile”, etc.)
      1. modules “parser” et “ast”
      2. création de documentation avec “pydoc”
   2. décorateurs

1. typage général
   1. Python n'est pas typé…
   2. … mais Python est typé
   3. types natifs et types définis
      1. natifs :
         1. numériques
         2. séquences
         3. dictionnaires
         4. classes
         5. instances
         6. exceptions
      2. natifs étendus :
         1. classe (cf “dict”)
         2. module (dont “collections.*” ; cf “class”)
         3. fonction et méthode (cf “class”)
      3. définis lors de l'exécution ⇒ par défaut dans l'interpréteur CPython et ceux de l'utilisateur
2. le typage avancé
   1. types mutables et non-mutables
   2. typage et liens logiques ⇒ annotation
      1. module 'typing'
   3. appel de fonction “C” ⇒ proxy de paramétrage
      1. module 'ctypes'

1. les 7 primitives de programmation interprétée (vision classique)
2. Forth vs LISP : les deux familles originales
3. cas du C
4. cas de l'assembleur
5. notion avancée de macro
6. créer un compilateur d'un langage à partir de ce langage