En informatique, les variables sont des éléments qui associent un nom à une valeur. La valeur peut être d’un type différent : un nombre, un texte, etc… Une fois déclarée, la variable est stockée dans la mémoire physique de l’ordinateur. Suivant le type de variable, la taille de la mémoire occupée ne sera pas la même. Le choix du type aura donc un effet direct sur la performance du programme. Cependant, je vous rassure, pour nos premiers scripts, la performance ne sera pas le premier critère mais il est bon d’avoir ces notions en tête.
Suivant les langages, les variables doivent être soit déclarées avant de les utiliser soit déclarées dynamiquement lors de leur première utilisation. Pour illustrer ce dernier point, cela signifie que les variables sont déclarées lors de leur première apparition et pas au début du script comme on peut le voir souvent lorsqu’on se trouve dans le premier cas.
Bien entendu, comme son nom l’indique, un variable pourra changer de valeur au cours de l’exécution du programme. Dans certains cas particulier il pourra être intéressant de définir des constantes qui pourront être appelées dans n’importe quel module du programme. Enfin, certaines variables peuvent être dites globales, c’est-à-dire que leur valeur pourra changer au fur et à mesure du programme et pourra être appelée par n’importe quel module. Cette dernière méthode est à proscrire. Si vous avez besoin d’une variable dans une fonction, il faudra la mettre en argument. Vous trouverez plus d’informations sur les fonctions dans les articles dédiés pour le VBA et pour le Python.
La notion de global et local
Votre programme sera construit de la manière suivante :
Vous avez donc votre programme principal avec ses instructions. Les variables créés dans ce bloc sont dites globales et peuvent servir à tous les sous-programmes.
Lors de l’exécution de votre programme principal, il viendra appeler les différents sous-programmes. Ces sous-programmes peuvent être des modules qui exécuteront une tâche spécifique ou un fonction qui effectuera une action et renverra une valeur.
Les variables crées dans les sous-programmes ont donc une durée de vie limitée à l’exécution de ceux-ci. Ce sont alors des variable locales car une fois l’exécution du programme terminée, elles sont supprimées de la mémoire.
Les grands types de variables
Ce paragraphe vous présente les principaux types de variables que vous utiliserez. Nous irons ensuite plus dans le détail dans la section suivante. En effet, chaque type de variable fonctionne de façon différente et ne sera pas manipulé de la manière manière. Voici une liste des grands types de variables disponibles quand vous allez créer vos outils automatiques :
Integer : nombre entier (exemple : 1 ou 21)
Ou également « int » en abrégé, ce sont des nombres entiers. Suivant les calculs que vous réaliserez, les décimales ne sont pas nécessairement utiles. De plus ce type de variable est très souvent utilisé pour les boucles « for » et « while ». Un incrément (souvent appelé « i ») verra sa valeur évoluer de 1 en 1 par exemple. Toutes les valeurs prises par la variable seront donc forcément des nombres entiers.
Côté performance, les variables de type « entier » prennent moins de place dans la mémoire que des nombres réels (voir section suivante). Pour titre d’exemple, nous allons voir comment le type de variable joue sur la mémoire. Une variable est codée dans la mémoire en bit. Un bit peut prendre la valeur de 0 ou 1, c’est donc un système binaire. Si on considère 8 bits, cela forme un octet. Soit une variable de type entier, uniquement positive, codée sur un octet pourra donner un nombre compris entre 0 et 255. Explications : chaque bit représente une puissance de 2, car je le rappelle c’est un système binaire, en partant de 2^0 jusqu’à 2^7 car nous avons 8 bits. voici quelques exemples :
- [00000000] = 0*2^0 + 0*2^1 + 0*2^2 + 0*2^3 + 0*2^4 + 0*2^5 + 0*2^6 + 0*2^7 = 0
- [11111111] = 1*2^0 + 1*2^1 + 1*2^2 + 1*2^3 + 1*2^4 + 1*2^5 + 1*2^6 + 1*2^7 = 255
- [01011000] = 0*2^0 + 1*2^1 + 0*2^2 + 1*2^3 + 1*2^4 + 0*2^5 + 0*2^6 + 0*2^7 = 26
Le tableau ci-dessous reprend les trois exemples précédents synthétisés dans un tableau :
Si maintenant nous voulons utiliser des nombres entiers positifs ET négatifs, un bit devra être dédié au signe. Ceci a pour effet de réduire la capacité de la variable car nous avons maintenant 7 bits pour la valeur et 1 bit pour le signe. La plage de valeur pour un entier codé sur un octet va donc de -128 à +127. Ce n’est pas symétrique car le zéro est déjà codé une fois côté positif ce qui laisse une possibilité de plus côté négatif.
Float : nombre à virgule flottante (exemple : 3.14)
Ces variables sont des nombres réels, c’est-à-dire des nombres à virgule avec une partie décimale. Si vous avez des calculs à réaliser, via une formule ou autre, vous serez obligés de passer par ce type de variable. comme vous pouvez l’imaginer, pour une même plage de valeur, ces variables prendront plus de place dans la mémoire. Ce type de variable est très largement utilisé.
Booléen : Vrai ou Faux
Les variables booléenne ne prennent que deux valeurs : Vrai ou Faux. On pourrait faire avec un entier qui prend 0 ou 1 comme valeur mais comme évoqué précédemment, pour un souci d’économie, nous préfèrerons déclarer le bon type de variable. En effet, une variable booléenne peut être codée sur 1 bit seulement.
Booléen vient de l’algèbre de Boole qui est une partie des mathématiques appliquée à la logique (vrai ou faux, enchainement de séquence qui ont pour réponse Vrai ou Faux et le chemin emprunté dépend de la réponse.
Personnellement j’utilise ces variables pour réaliser des contrôles afin de déclencher ou non certaines fonctions du programme. On verra qu’il est possible aussi d’écrire les lignes de code en se passant de ce type de variable. Cependant, je trouve qu’elles donnent une certaine lisibilité au code.
String ou variable texte
Si vous manipulez des lettres, des mots ou des fichiers texte, vous utiliserez alors des variables de type « string ». Ce type de variable vous permettra de manipuler des chaînes de caractères, très utile lorsque vous travaillez dans un document texte. Un fichier texte se lit ligne par ligne, vous aurez donc à traiter chaque ligne comme une chaîne de caractère. Des fonctions déjà intégrées au code permettront de travailler sur cet enchainement de caractère. Vous pourrez par exemple la diviser suivant un caractère donné, trouver et remplacer une chaîne de caractère et toute autre sorte de manipulation.
Array : tableaux
Les tableaux permettent de stocker les variables vues précédemment. En créant des tableaux, vous pourrez ordonner vos données et ainsi créer des boucles sur les lignes et les colonnes afin de récupérer les valeurs. Vous pouvez stocker dans vos tableaux une liste d’entiers ou de nombres réels. La seule contrainte est que vous devez avoir le même type dans tout le tableau. D’autres types de variable permettent d’avoir un type différent par colonne mais nous le verrons plus tard.
Object
Les objets sont des variables structurées qui peuvent être caractérisées par des attributs et des fonctions ou méthodes. Pour illustrer l’utilité de ce type de variable, pour caractériser une voiture, nous lui attribuons une couleur, une marque, nombre de passagers, longueur, etc … Nous pourrions définir un tableau où chaque ligne aurait la valeur de ces caractéristiques. Un objet aura pour attributs les mêmes caractéristiques. Sauf que nous savons à l’avance que chaque objet aura les mêmes attributs. Chaque nouvel objet sera alors instancié et aura les mêmes propriétés que les autres. Cela permet d’avoir un cohérence dans votre programme et permet également une meilleure lisibilité plutôt que de travailler sur un tableau.
Les spécificités de VBA
Pour les nombres entiers, vous pouvez déclarer un type « integer » ou « long ». La première est stockée sur 4 octets et la seconde sur 8 octets. L’étendue de cette dernière est donc beaucoup grande mais elle prend plus de place dans la mémoire.
J’utilise aussi dans certains cas les types « Byte » (allant de 0 à 255) et « Sbyte » (allant de -128 à 127), les deux codés sur 1 octet. Lorsque je sais que mes itérations ne dépasseront pas une ces seuils, je me permets d’utiliser ces types.
dim variable_entier as integer
dim variable_entier2 as longIl y a le même raisonnement pour les variables qui auront des nombres à virgules flottantes. Le type « single » est codé sur 4 octets et le type « double » sur 8 octets. Voici comment les déclarer :
dim variable_reel1 as single
dim variable_reel2 as doubleD’autres types peuvent être utilisés suivant les cas, vous aurez plus de détails via le lien suivant :
https://learn.microsoft.com/fr-fr/dotnet/visual-basic/language-reference/data-types/
Les spécificités de Python
On retrouve en Python les mêmes types vus précédemment. Voici un exemple sur la manière de les déclarer. On rappelle qu’en Python, le typage se fait dynamiquement lors de l’assignement de la variable.
variable_entier = 7
variable_reel = 3.14
variable_bool = FalseA ces variables se rajoutent les types suivants :
- Les listes (list) : ces variables permettent de stocker une séquence de variable simple qui peuvent être de différents types. Les éléments d’une liste sont ordonnés et peuvent être accéder via un index tout comme fonctionnerait un tableau
- Les tuples : les tuples sont similaires aux listes mais sont immuables. En d’autres termes, une fois créés, les éléments ne peuvent pas être modifiés.
- Les dictionnaires (dict) : ce type de variable permet de stocker des paires clé / valeur où à chaque clé est associée la valeur donnée. Les éléments d’un dictionnaire ne sont pas ordonnés. Les valeurs sont accessibles via la clé correspondante.
Conclusion
Certains types peuvent être retrouvés dans l’un des deux codes sous différents noms ou différentes formes. J’ai volontairement éviter d’être exhaustif pour rester sur l’essentiel. Voici la liste des variables importantes que vous utiliserez principalement :
- type entier (Integer ou Long en VBA, int en Python)
- type réel à virgule flottante (Single ou Double en VBA, float en Python)
- Booléen (Boolean)
- Chaîne de caractères (String)
Une fois que maitriserez ces différentes variables, vous pourrez aller passer sur des structures plus complexes. La structure la plus simple est un tableau ou une liste en Python. Elles vous permettront de stocker davantage de données.
L’étape suivante sera l’utilisation de variable de type « objet » où vous pourrez définir vous même une variable complexe, constituée de fonctions, de méthodes, d’attributs et d’autres variables internes. Enfin, pour ceux qui souhaitent traiter un grand nombre de données, en python vous aurez les « dataframe » avec la librairie Pandas. Nous en parlerons plus dans un futur article.
J’espère vous avoir donné un bon aperçu sur les variables en programmation. Merci de m’avoir lu et n’hésitez à laisser vos commentaires.
A bientôt, Benjamin
L'article vous a plu ?
Recevez gratuitement en complément le guide
"Débutez avec Python et libérez vos compétences."
Ce guide vous permettra d'acquérir les bases pour commencer à créer vos propres outils automatiques.
Promis, je hais les spams : votre adresse email ne sera jamais cédée ni revendue. En vous inscrivant ici, vous recevrez des articles, vidéos, offres commerciales et autres conseils pour vous aider à développer vos compétences en Python. Voir mentions légales complètes en bas de page. Vous pouvez vous désinscrire à tout moment !
