Le vocabulaire de la programmation illustré en Python

# Import d'une librairie
import os

# Import d'un module, d'une fonction…
from os import environ

# Une variable s'écrit en snake_case et en minuscule
# La valeur d'une variable peut changer, mais par convention, vous ne changerez (presque) JAMAIS son type (Un entier doit rester un entier…)
# Le signe = signifie que la valeur 1 est assignée / affectée à la valeur 1
# Techniquement, la valeur est créée et stockée en mémoire et la variable pointe vers la valeur stockée
variable = 1

# Une constante s'écrit en SNAKE_CASE et en MAJUSCULE. 
# Par convention, sa valeur ne doit JAMAIS changer dans le programme, même si techniquement, vous pouvez la changer. 
# Ici la valeur assignée à la CONSTANTE est l'entier 1.
CONSTANTE = 1

# Une variable d'environnement est une donnée récupérée dans votre environnement
# Bien que l'on puisse changer sa valeur dans l'environnement, dans 99,9% des cas, elle est CONSTANTE dans votre programme
# Utiliser des variables d'environnement vous garantit la portabilité de votre code sur différentes plateformes sans avoir à adapter le code
VARIABLE_ENVIRONNEMENT = os.environ.get("VARIABLE_ENVIRONNEMENT", 1)

# Une fonction est une séquence d'instructions qui réalisent une tâche
# La fonction retourne toujours une valeur
# On peut lui définir des arguments obligatoires et optionnels
# le nom de la fonction et des arguments s'écrivent en snake_case
def fonction(argument, argument_optionnel = "arg"):
    """ une fonction retourne une valeur """
    
    resultat = argument + "d'autres trucs"
    return resultat

# Une procédure est aussi une séquence d'instructions qui réalisent une tâche
# Contrairement à la fonction, la procédure ne renvoie pas de valeur
# Mais techniquement, une procédure retournera toujours la valeur None
def procedure(argument):
    """ une procédure ne retourne pas de valeur. Elle retourne systématiquement None """
    
    resultat = argument + "d'autres trucs"
    print(resultat)

# Un décorateur est une fonction qui englobe une autre fonction
# La fonction englobée est dite : décorée
# le terme @decorateur est un raccourci qui lie la fonction decorateur() à la fonction_decoree()
# Comme le décorateur est englobant, il peut exécuter du code avant et après l'appel de la fonction / procédure / méthode décorée
@decorateur
def fonction_decoree(argument, argument_optionnel = "arg"):
    """ Je suis une fonction décorée, mon décorateur exécute des instructions avant et après moi """
    
    resultat = argument + argument_optionnel + "d'autres trucs"
    print(resultat)


# Une classe est un ensemble incluant des variables, attributs et méthodes.
# Une variable s'écrit en CamelCase
class NomDeLaClasse : 
    # Les attributs sont des variables accessibles depuis toute méthode de la classe dans laquelle elles sont définies
    attribut = "un attribut" 
 
    # Une méthode est une fonction rattachée à une classe
    # Une méthode est reconnaissable à son premier argument qui sera toujours : self
    def methode_de_classe_1(self, argument):
        """ cette méthode est une fonction """
        
        return "Je suis une méthode de la classe NomDeLaClasse"
    
    # Une méthode peut aussi être une procédure rattachée à une classe
    def methode_de_classe_2(self, argument):
        """ cette méthode est une procédure """
    
        print("Je suis une méthode de la classe NomDeLaClasse")


# L'appel d'une fonction signifie que l'on demande l'exécution du code interne à une fonction
# On reconnait l'appel d'une fonction à la présence des parenthèses après le nom de la fonction
# Techniquement, les parenthèses sont considérées comme le caller dans le parsing de la syntaxe à l'interprétation
# Ici, la valeur qui sera retournée par la fonction sera affectée à une variable
variable = fonction("plop")

# Appel d'une fonction définie avec des arguments positionnels (arg = argument)
# Un argument positionnel est
variable = fonction("plop", "plop")

# Appel d'une fonction définie avec des arguments à mots clés (kwarg = keyword argument)
variable = fonction(argument="plop", argument_optionnel="plop")

# Appel d'une fonction définie avec un argument positionnel (arg = argument) et un argument à mot clé (kwarg = keyword argument)
variable = fonction("plop", argument_optionnel="plop")

# Appel d'une procédure
procedure("plop")

# Instanciation d'une classe
instance_classe = NomDeLaClasse("plop")

# Appel d'une méthode d'une classe instanciée
instance_classe.methode_de_classe_1("plop")

# Création d'une référence vers une classe
ReferenceNomDeClasse = NomDeLaClasse

# Création d'une référence vers une fonction
reference_fonction = fonction

# Création d'une référence vers une procédure
reference_procedure = procedure

# Une liste
liste = [1, 2, 3]

# Une boucle 
for i in liste :
    print(i)
    
# Une liste de compréhension (astuce mémo technique : je liste des éléments i en parcourant "liste")
# La valeur retournée est une liste
liste_2 = [i for i in liste]

# Un générateur (à ne pas confondre avec la liste de compréhension)
# La valeur retournée est un générateur
# Un générateur doit être itéré à l'aide d'une boucle (for par exemple) pour accéder à son contenu qui est généré à chaque itération
generateur = (i for i in liste) 

# Un dictionnaire composé d'une clé et d'une valeur
dictionnaire = {"Bla": "Bla"}

# Un cast signifie que vous changez le type d'une variable
# Ici, l'entier 1 est casté en chaine de caractère
chaine = str(1)