L’instruction suivante a pour effet de créer une variable de nom v et d’y mettre du rien :

v = None

En effet l’objet None est vide (il ne possède pas vraiment de valeur, ou plutôt on modélise cette valeur par None). En modélisant mathématiquement une variable par un couple (nom,valeur) ou une boîte contenant une valeur et portant une étiquette avec un nom, la variable de nom v que l’on a créée ci-dessus est une boîte portant l’étiquette « v » mais vide.

En entrant

id(v)

on apprend à quel emplacement de la mémoire vive, se situe cet objet vide. Il n’y a qu’un seul emplacement car il n’y a qu’un seul vide : on dit que le rien est un singleton (patron de conception).

En entrant

type(v)

on a l’affichage

<class 'NoneType'>

qui suggère que le rien est un type.

Pour connaître les méthodes de cet objet vide, on peut entrer dans la console

dir(v)

ce qui donne quelque chose comme

['__bool__', '__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']

Somme toute, il y a pas mal de choses que l’on peut faire avec le vide !

Et bien cela dépend. Le vide se pare avant de sortir. Il peut être invisible ou au contraire apparaître clairement aux yeux de tous. Dans la console, entrer v n’a pas le même effet qu’entrer print(v). Dans le premier cas, est invoquée la méthode __repr__ (qui renvoie la chaîne vide et nous est donc invisible) alors que dans le second cas, c’est la méthode __str__ qui est appliquée, et celle-ci renvoie la chaîne de caractères

'None'

Puisqu’on a vu que le vide avait un type, qu’on pouvait même le voir, on est en droit de se poser la question : a-t-il une taille ?

v.__sizeof__() Nous renseigne efficacement :

16

Mais alors, en Python, peut-on être un moins que rien ? Quelques tests nous incitent à penser que non :

x = 0
x.__sizeof__()

nous donne :

24

s = ''
s.__sizeof__()

nous donne :

49

Il n’y a qu’à demander à Python :

v == v

La réponse True est éclairante !

v == True
False

v == False
False

Oh ! Le vide n’est ni vrai ni faux. Pourtant :

if v:
   print('Le vide est vrai')
else:
   print('Le vide est faux')

Nous affiche :
Le vide est faux

En réalité, l’expression

bool(v)

s’évalue à False

En écrivant help(v) on obtient cette description du rien :

Help on NoneType object:

class NoneType(object)
 |  Methods defined here:
 |  
 |  __bool__(self, /)
 |      self != 0
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __repr__(self, /)
 |      Return repr(self).
(END)

Ceci confirme qu’on peut convertir du rien en proposition logique (on obtient False comme réponse à la question self != 0 ce qui signifie que le vide n’est pas différent de zéro - est-il pour autant égal à 0 ?- non car v==0 donne aussi l’affichage False), qu’on peut créer le vide (mais une seule fois) et qu’il possède une représentation qui est la représentation du vide.

En programmation fonctionnelle, et en particulier en Haskell, l’équivalent du None de Python s’appelle le type unité. Il se note par des parenthèses vides. Pour savoir (avec ghci qui est une console interactive en Haskell) de quel type est le rien, on entre

:t ()

ce qui donne l’affichage suivant :

() :: ()

ce qui signifie que le rien est du type du rien. On s’en doutait un peu quand même.

En Haskell, le rien (appelé unité) sert à définir des fonctions impures comme cette fonction afficher :

let afficher texte = print texte

qui a pour but d’afficher du texte, et non de renvoyer une valeur. Pour connaître son type on demande à Haskell

:t afficher

et on obtient

afficher :: Show a => a -> IO ()

Ce qui est avant le => signifie que si a est un type compatible avec Show (quelque chose qu’on peut montrer) alors la fonction afficher est de type a -> IO () c’est-à-dire le type d’une fonction qui, à a, associe ce qu’on obtient en enveloppant le rien (les parenthèses vides) dans une monade IO (comme « input-output » ; c’est la monade qui contient print).

C’est là l’utilité en Haskell d’avoir du rien : c’est ce rien que renverra une fonction comme afficher qui sert à faire quelque chose (afficher son argument) et non à renvoyer quoi que ce soit : à la place cette « fonction » renvoie du rien.

On peut (un peu arbitrairement) classer les fonctions de Python en trois catégories :

• Les fonctions pures qui ne servent qu’à renvoyer quelque chose (elles ne font pas d’effet de bord) ;
• les fonctions impures qui renvoyent quelque chose mais, en plus, modifient leur environnement (exemple la méthode pop qui fait sauter le bouchon du saké avant de renvoyer le bouchon) ;
• les procédures qui ne font que des effets de bord.

Les spécialistes de la programmation fonctionnelle n’aiment pas utiliser le mot « procédure » mais celui-ci est peut-être plus naturel en mathématiques où une fonction a vocation à être composée avec une autre fonction, pas à modifier l’environnement.

Or en Python comme dans les langages fonctionnels il n’y a pas de possibilité de distinguer les fonctions des procédures, on propose en général de remplacer le mot « procédure » par l’expression « fonction ne renvoyant rien ».

Cette fonction ne renvoie rien :

def rien1():
    return

On verra plus bas que même le mot-clé return est facultatif. Mais ici c’est une instruction (et non une fonction) intimant à la machine l’ordre de quitter le corps de la fonction. Cette fonction ne renvoie donc rien, comme on peut le constater en entrant dans la console rien1() et en constatant que rien n’est affiché (puisque rien n’est renvoyé et que la console devait afficher ce que renvoie la fonction, c’était prévisible).

On obtient exactement la même chose (c’est-à-dire rien) en entrant dans la console rien2() après avoir défini la fonction suivante :

def rien2():
    return None

On ne sait jamais, il se pourrait qu’en cachette les deux fonctions rien1 et rien2 ci-dessus ne fassent pas exactement la même chose dans les arcanes de la machine. Pour en savoir plus on peut utiliser le module de désassemblage de bytecode fourni avec Python. En anglais « désassemblage » se traduit par disassemble et tant le module que la fonction se nomment dis.

On écrit donc

from dis import *

avant les définitions des fonctions rien1 et rien2 puis, après les définitions, dis(rien1) ou dis(rien2) permet de savoir comment chacune est exécutée pas à pas par la machine virtuelle Python.

Les deux fonctions donnent exactement le même bytecode :

  4           0 LOAD_CONST               0 (None)
              3 RETURN_VALUE

Il n’y a, côté assembleur, que deux lignes :

• La ligne 4 consiste à charger la valeur qui sera renvoyée par la fonction. Il s’agit d’une constante de taille 0 octet et de valeur None.
• La ligne suivante (3 car il y a eu changement dans la taille de la pile) est le retour de la valeur en question : tout ce qui concernait l’exécution de la fonction est oublié (dépilé) et la constante None est renvoyée à ce moment-là.

Ceci signifie qu’en réalité, renvoyer du rien revient effectivement à ne rien renvoyer, ou plutôt l’inverse : Python insère automatiquement un None derrière return, s’il n’y a rien. Autrement dit, s’il voit un return sans rien derrière, il considère que ce rien est None (ce qu’on ne peut guère lui reprocher) et renvoie None, comme s’il avait vu return None.

Et si on essayait de ne même pas mettre de ligne avec return ?

Pas si facile : si on essaye d’entrer

def rien3():
    

on a un message d’erreur sur l’indentation non respectée après le double-point (une ligne vide n’est pas une ligne indentée).

Pour éviter ce désagrément on peut, ou bien mettre quelque chose d’inutile genre a=a ou bien faire

def rien3():
    pass

Cette nouvelle fonction donne exactement le même bytecode que les deux précédentes comme on peut le vérifier en la soumettant à la fonction dis de désassemblage.

Quitte à ne rien faire, pourquoi pas le (pas) faire plusieurs fois ?

La fonction suivante accepte un entier n en entrée, puis répète n fois l’action (ou plutôt la non-action) de ne rien faire :

from time import *

def repassage(n):
    t = time()
    for _ in range(n):
        pass
    return time()-t

Noter que si on appelle la fonction avec un argument nul, elle ira encore plus loin que ne rien faire puisqu’elle fera rien, zéro fois. Y a-t-il une langue au monde qui possède un verbe pour cette non-action (ne rien faire, mais zéro fois) ?

En fait la fonction repassage n’est pas sage : Elle chronomètre le temps pris à ne rien faire. Et il semble intéressant d’évaluer ce temps, notamment pour de grandes valeurs de n. Ce script le permet :

from matplotlib.pyplot import * # ligne à placer au tout début du script

zen = [repassage(n) for n in range(1000)]
plot(range(1000),zen,'b.')
show()

Le résultat est que mine de rien ça prend quand même un peu de temps, de ne rien faire (même si n est égal à zéro : le temps de l’appel à la fonction) :

On voit que la droite ne passe pas tout-à-fait par l’origine : Ne rien faire zéro fois prend très peu de temps mais un peu de temps quand même. Par contre la paresse itérée est plus chronophage que la paresse occasionnelle.

Mais à quoi peut donc servir cette instruction qui ne fait rien ? C’est une histoire de gabarit. Par exemple, lorsqu’on veut créer son propre objet, on a intérêt à donner la liste des méthodes avant de voir comment on programme les méthodes. On commencera donc typiquement à écrire quelque chose comme

class MonObjet():
    def méthode1(self):
        pass
    def méthode2(self):
        pass

Ensuite on teste avec un script du genre

o = MonObjet()
o.méthode1()
o.méthode2()

S’il n’y a aucun message d’erreur, et dans ce cas seulement, on commence à réfléchir à ce qu’on va mettre à la place des pass.

On a vu une autre application de cette instruction dans cet article : Les méthodes des variables de Sofus ne sont pas accessibles depuis le menu des fonctions de la calculatrice, et il est donc pratique de créer des fonctions globales ayant le même nom, mais ne faisant rien. Elles ne font donc que passer à la fin de ce script.