Blog ENI : Toute la veille numérique !
Accès illimité 24h/24 à tous nos livres & vidéos ! 
Découvrez la Bibliothèque Numérique ENI. Cliquez ici
💥 Les 22 & 23 novembre : Accès 100% GRATUIT
à la Bibliothèque Numérique ENI. Je m'inscris !
  1. Livres et vidéos
  2. Python 3
  3. Déclarations
Extrait - Python 3 Les fondamentaux du langage (4e édition)
Extraits du livre
Python 3 Les fondamentaux du langage (4e édition)
4 avis
Revenir à la page d'achat du livre

Déclarations

Variable

1. Qu’est-ce qu’une variable ?

a. Contenu

Le contenu d’une variable est sa valeur, stockée en mémoire. Il s’agit forcément d’un objet, autrement dit, de l’instance d’une classe. Le type de l’instance est le nom de sa classe.

Par exemple 42 est une instance de la classe int, elle est de type int :

>>> type(42) 
<class 'int'> 

Toute opération réalisée sur une variable l’est sur sa valeur.

b. Contenant

Le contenant n’est rien d’autre que l’association d’un nom, appelé identificateur, et d’un pointeur vers le contenu, soit la valeur associée à ce nom.

L’affectation est l’opération qui permet d’associer un contenu (opérande de droit) à un contenant (opérande de gauche) et donc d’associer un identificateur avec un pointeur vers une valeur.

>>> a = 42 

Ainsi, l’utilisation de ce nom renvoie systématiquement la valeur associée :

>>> a 
42 

L’unique moyen de supprimer cette association entre contenu et contenant est de supprimer l’association entre le nom et le pointeur :

>>> del a 

Le contenant n’existe alors plus, et il n’est plus possible d’utiliser le nom de variable :

>>> a 
Traceback (most recent call last): 
  File "<stdin>", line 1, in <module> 
NameError: name 'a' is not defined 

Le fait que le contenant n’existe plus ne signifie pas forcément que le contenu associé n’existe plus en mémoire, car si un contenant n’est associé qu’à un seul contenu, un contenu peut être associé à plusieurs contenants.

Pour savoir si les contenants pointent vers le même contenu, il faut procéder ainsi :...

Fonction

1. Déclaration

La déclaration d’une fonction est extrêmement aisée, comme vu au chapitre précédent. Il suffit d’utiliser le mot-clé def, de le faire suivre par le nom donné à la fonction puis par des parenthèses ouvrantes et fermantes pouvant éventuellement contenir une liste d’arguments et les deux-points.

On ouvre ainsi un bloc qui possède son propre espace de nommage local et qui contient les instructions de la fonction. Il se termine par le retour d’une variable et si cela n’est pas écrit explicitement par une instruction, la fonction retourne None.

Le nom de la fonction doit de préférence être un nom représentatif de la fonction. Ce nom est aussi le nom de la variable (contenant) dont la valeur est la fonction, qui est un objet (contenu).

Si une variable portant le nom de la fonction est déjà prédéfinie, elle est remplacée par la fonction, exactement de la même manière que lors d’une opération d’affectation.

Voici une fonction vide :

>>> def f(): 
...     pass 
... 

Voici les attributs ou méthodes de l’objet fonction :

>>> list(set(dir(f))-set(dir(object))) 
['__module__', '__defaults__', '__annotations__', '__kwdefaults__', 
'__globals__', '__call__', '__closure__', '__dict__', '__name__', 
'__code__', '__get__'] 

On voit qu’une fonction est rattachée au nom du module qui contient sa définition :

>>> f.__module__ 
'__main__'  

On voit également qu’elle porte son nom :

>>> f.__name__ 
'f 

Cette caractéristique est propre à la fonction et non au nom de la variable :...

Classe

1. Déclaration

a. Signature

Pour déclarer une classe, le mot-clé class est utilisé, suivi du nom de la classe, des parents entre parenthèses et d’un bloc qui représente l’encapsulation des données de la classe, attributs et méthodes confondus.

Voici le service minimum :

>>> class A: 
...     pass 
... 

Une telle syntaxe est à proscrire en Python 2.x, puisqu’il faut impérativement utiliser les nouvelles classes (nouvelles depuis la version 2.2) :

>>> class A(object): 
...     pass 
... 

L’utilisation de cette dernière forme est pour Python3 exactement identique à la forme précédente. Le changement de branche permet que l’écriture avec l’ancien style crée tout de même une classe du nouveau style, puisque l’ancien n’existe définitivement plus.

Ainsi quelle que soit la manière d’écrire de la classe précédente, on a :

>>> type.mro(A) 
[<class '__main__.A'>, <class 'object'>] 

b. Attribut

Un des principes essentiels d’un langage objet est l’encapsulation, impliquant qu’une donnée relative à une classe appartient à la classe. La conséquence est la nécessité d’avoir un accesseur qui puisse permettre de retrouver la donnée à partir de la classe ou d’une instance de la classe. Cela signifie aussi, à part pour la programmation objet par prototype, que ces données sont déclarées dans le bloc de la classe.

En Python, tout se joue par l’indentation :

>>> class A(object): 
...     attribut = 42 
... 

L’accesseur est simplement le point et l’attribut appartient à...

Module

1. À quoi sert un module ?

Un module est le regroupement d’un ensemble de fonctionnalités au sein d’un même fichier. Ainsi, décider de ce qu’il contient est votre prérogative, même s’il y a des pratiques usuelles qui gagnent à être respectées.

Un module est donc une brique dans la construction de votre application. Appelé directement (exécuté) il s’agit du point d’entrée de votre application.

2. Déclaration

Un module Python est tout simplement un fichier portant l’extension .py ou .pyc (version python ou version compilée) ou encore écrit directement en C (pour l’implémentation CPython). Ce peut être également un répertoire.

Un module est donc un bloc et il possède son espace de nommage qui peut contenir des variables, des fonctions, des classes mais aussi d’autres modules.

Contrairement à d’autres langages, il n’y a pas de règles en Python qui imposent une classe par fichier donc par module. Ceci est même contre-productif, puisque cela signifie qu’un module ne peut contenir qu’une classe.

Cela est même contraire aux bonnes pratiques de conception logicielle qui, en Python, tire parti de ce concept de module pour permettre la mise en place d’une architecture du code souple et logique.

Un module Python peut intégrer un autre module et il peut être réalisé une hiérarchie plus ou moins complexe. Si les modules de plus bas niveau sont des fichiers, les modules de plus haut niveau sont des répertoires.

Ces modules-là ne contiennent donc rien d’autre que des sous-modules. Cependant, il est possible de leur ajouter d’autre contenu en créant dans le répertoire du module un fichier __init__.py qui contienne le code des éléments spécifiques...