Syntaxe et Instructions

• # : introduit un commentaire dans le code.
• \\ : sert à poursuivre une instruction sur la ligne suivante, bien que cette pratique nuise à la lisibilité et soit donc découragée.
• ; : permet de regrouper plusieurs instructions sur une seule ligne, ce qui réduit la clarté et est également déconseillé.
• : : sépare l'en-tête d'une instruction de son bloc de code associé.
• Les blocs de code sont délimités par l'indentation ; il est recommandé d'utiliser 4 espaces (éviter les tabulations) pour marquer les niveaux hiérarchiques.
• Les fichiers Python s'organisent sous forme de modules : un fichier se terminant par .py constitue un module.

Définition et Affectation des Variables

Dans une instruction telle que a = 1, la valeur 1 est stockée en mémoire, tandis que a agit comme une référence à cet objet. Python étant un langage dynamique, il n'est pas nécessaire de déclarer le type d'une variable au préalable ; le type est inféré automatiquement lors de l'affectation.

Contrairement au langage C, une affectation en Python ne renvoie pas de valeur. De plus, alors que C exige que les déclarations de variables soient placées en début de code, des langages comme C++ ou Java permettent des déclarasions à tout moment, mais avec obligation de spécifier le nom et le type. En Python, les variables peuvent être créées à la volée, leur type étant déterminé dynamiquement par l'interpréteur. Il est crucial de noter qu'une variable doit recevoir une valeur avant d'être utilisée.

Gestion de la Mémoire

Principes généraux

• Les variables n'ont pas besoin de type explicite.
• La gestion de la mémoire est automatique et transparente pour le développeur.
• Les objets inutilisés sont récupérés automatiquement via le ramasse-miettes.
• L'instruction del permet de supprimer directement une référence, réduisant ainsi le compteur de références de l'objet associé.

Comptage des références

Le comptage de références s'incrémente lorsque :

1. Un objet est créé et sa référence est assignée à une variable (par exemple, x = 1).
2. La même référence est attribuée à une autre variable (par exemple, y = x).
3. L'objet est passé en argument à une fonction.
4. L'objet devient un élément d'un conteneur, comme une liste.

Il se décrémente lorsque :

1. Une variable locale est détruite à la fin de l'exécution d'une fonction.
2. Une varible est réaffectée à un nouvel objet.
3. La référence est supprimée avec del.
4. L'objet est retiré d'un conteneur (par exemple, via la méthode remove).
5. Le conteneur lui-même est détruit.

Le ramasse-miettes de Python, qui combine un compteur de références et un collecteur pour les références circulaires, gère la récupération de la mémoire. Lorsque le compteur de références tombe à zéro, l'objet est éligible à la suppression, mais cette suppression n'est pas instantanée en raison de possibles cycles.

Illustration simple

objet = 10  # Création de l'objet 10 en mémoire, référence assignée à 'objet', compteur = 1
copie_ref = objet  # Le compteur de références de l'objet 10 passe à 2
copie_ref = 20  # Un nouvel objet 20 est créé, 'copie_ref' pointe vers celui-ci ; le compteur de 10 redescend à 1
del objet  # Suppression de la dernière référence à l'objet 10, il sera récupéré par le ramasse-miettes

Objets en Python

Python stocke les données sous forme d'objets. Les fonctions usines pour créer des types de données sont en réalité des classes, et toute instanciation génère un objet. Chaque objet possède trois caractéristiques :

• Identité : adresse mémoire, vérifiable avec la fonction id(). Deux objets avec la même identité sont en fait le même objet.
• Type : déterminable avec type(), qui renvoie également un objet représentant le type.
• Valeur : les données contenues dans l'objet.

Identificateurs

Un identificateur est une chaîne de caractères valide servant de nom. Les règles sont :

• Le nom doit avoir un sens et être lisible.
• Il doit commencer par une lettre ou un underscore (_).
• Les caractères suivants peuvent être des lettres, chiffres ou underscores.
• La casse est sensible (majuscules et minuscules distinguées).
• Deux styles courants : snake_case (par exemple, connexion_db) ou CamelCase (par exemple, ConnexionDB).
• Il est interdit d'utiliser des mots-clés du langage ou des noms réservés de l'interpréteur (built-ins).

Les built-ins sont des fonctions et constantes importées automatiquement par l'interpréteur, considérées comme des variables globales.

Identificateurs avec Underscores Spéciaux

Les underscores dans les noms de variables ont des significations spéciales en Python :

• _xxx : ce nom n'est pas importé lors d'une importation avec * (par exemple, from module import *).
• __xxx__ : réservé aux noms définis par le système (méthodes spéciales ou attributs).
• __xxx : utilisé pour les variables privées au sein d'une classe.

Étant donné que les underscores sont utilisés par l'interpréteur pour des identificateurs internes, il est déconseillé de les utiliser pour des variables personnalisées, sauf pour indiquer des membres privés dans une classe (__xxx), ce qui est une bonne pratique.

À noter que la variable système __name__ prend une valeur différente selon le contexte : le nom du module si le fichier est importé, ou '__main__' s'il est exécuté directement. Dans une application Python, il est recommandé de n'avoir qu'un fichier principal contenant le code de plus haut niveau, tandis que les autres modules devraient encapsuler leur logique dans des fonctions ou classes. Il est courant d'utiliser __name__ pour placer des blocs de test à la fin du fichier.

Style de Base pour Écrire des Modules

Un module Python bien structuré suit généralement cet ordre :

1. En-tête avec informations d'encodage et shebang.
2. Docstring du module.
3. Importations nécessaires.
4. Définition de variables globales.
5. Définition de classes.
6. Définition de fonctions.
7. Code principal (si applicable).
8. Blocs de test conditionnels.

Exemple de Module

# -*- coding: utf-8 -*-
#!/usr/bin/env python

'''
Un module de démonstration pour les concepts de base.
'''

import sys
import os

mode_verbose = True

class DemonstrationClasse:
    '''
    Classe utilisée pour illustrer la définition d'objets.
    '''
    pass

def fonction_demo():
    '''
    Fonction principale pour les tests.
    '''
    print("Exécution de la fonction de démonstration.")

if __name__ == '__main__':
    fonction_demo()