Values, variables and constants

En bref

Résumé de l’article

Les concepts centraux de cet article sont les valeurs et les variables.
Une notion clé sous-jacente est liée aux types, qui déterminent les opérations possibles sur les valeurs.
Enfin, nous mentionnons un type plus complexe, appelé tableau (array), qui permet de travailler sur des collections de valeurs.

Points clés

• Les valeurs ont un type associé, qui définit les opérations possibles sur elles.

• Les variables sont des noms qui réfèrent à des valeurs susceptibles de changer, tandis que les constantes sont des noms qui réfèrent à des valeurs fixes.

• Favorisez toujours les variables et constantes plutôt que les valeurs dans votre code.

• Les langages de programmation définissent plusieurs types élémentaires, tels que booléens, entiers, nombres réels, chaînes de caractères, etc.

• Les structures de données permettent de regrouper des types simples en collections.

Contenu de l’article

1 — Valeurs, variables et constantes

Les algorithmes manipulent des valeurs telles que 34, 1.09, "IMT Atlantique" ou false qui peuvent être intégrées dans des calculs, par exemple 34 * 1.09 pour obtenir la conversion en euros de 34 dollars avec un taux de change de 1.09.
En plus de ces valeurs brutes, les algorithmes peuvent aussi manipuler des variables et des constantes.
Ce sont des noms qui représentent une valeur stockée en mémoire.

Manipuler de tels noms est bien plus pratique pour programmer, et surtout pour mettre à jour les codes.
Utiliser des variables dans votre algorithme permet d’éviter les erreurs et de rendre votre algorithme plus explicite.

Plus en détail :

• Une variable associe une valeur à un nom.
  Les valeurs associées à une variable peuvent changer pendant l’exécution du programme.

• Dans certaines situations, vous pouvez vouloir empêcher que la valeur assignée à une variable soit modifiée.
  Une façon de faire cela est d’utiliser des constantes.
  Techniquement, la valeur est stockée en mémoire et le nom de la variable/constante agit comme un lien vers cette adresse mémoire.
  Dans certains langages de programmation, tenter de modifier la valeur assignée à une constante provoquera une erreur.

• Assigner une valeur à une variable ou une constante s’appelle une “affectation”.

# Let's set three constants to represent the values 34, 1.09 and 1.5 in memory
# A standard convention is to write constants in capital letters to distinguish them from variables
AMOUNT = 34
RATE = 1.09
FEES = 1.5

# Now, let's define a variable using them
converted_amount = AMOUNT * RATE

# Later, we can update the variable if needed
# For instance, let's charge fees for conversion operations
converted_amount = converted_amount * FEES

# However, we are not supposed to change constants after their definition
# For instance, asjusting fees as follows is a bad practice
# In Python, it will work though, but many other languages will raise an error
FEES = 2

/**
 * To run this code, you need to have Java installed on your computer, then:
 * - Create a file named `Main.java` in a directory of your choice.
 * - Copy this code in the file.
 * - Open a terminal in the directory where the file is located.
 * - Run the command `javac Main.java` to compile the code.
 * - Run the command `java -ea Main` to execute the compiled code.
 * Note: '-ea' is an option to enable assertions in Java.
 */
public class Main {

    /**
     * This is the entry point of your program.
     * It contains the first codes that are going to be executed.
     *
     * @param args Command line arguments received.
     */
    public static void main(String[] args) {
        // Let's set three constants to represent the values 34, 1.09 and 1.5 in memory
        // A standard convention is to write constants in capital letters to distinguish them from variables
        // In Java, we explicitely indicate that these names are constant using keyword "const".
        const int AMOUNT = 34;
        const float RATE = 1.09f;
        const float FEES = 1.5f;

        // Now, let's define a variable using them
        float convertedAmount = AMOUNT * RATE;

        // Later, we can update the variable if needed
        // For instance, let's charge fees for conversion operations
        convertedAmount = convertedAmount * FEES;

        // However, we are not supposed to change constants after their definition
        // For instance, asjusting fees as follows is a bad practice
        // In Java, it will raise an error
        FEES = 2;
    }
}

2 — Types de base

Presque tous les langages de programmation considèrent qu’une valeur, et donc une variable (ou constante), a un type.

Le type d’une valeur détermine :

• L’espace mémoire nécessaire pour la stocker.
• Les opérations qui peuvent lui être appliquées.

Les langages de programmation fournissent des types de base et des mécanismes pour construire vos propres types composites.
Voici les principaux types de base que vous trouverez dans la plupart des langages de programmation :

• Entiers $\mathbb{Z}$ (ex. -35, 42, 0).
• Réels $\mathbb{R}$ (ex. 3.14, -13.49, $\sqrt{2}$).
• Booléens (true ou false).
• Caractères (ex. ‘!’, ‘X’, ‘\n’).
• Chaînes de caractères (ex. “IMT Atlantique”, “Hello!”, “?!”).

# Booleans
b = True
print(type(b))

# Integers
i = -35
print(type(i))

# Characters
new_line = '\n'
print(type(new_line))

# Strings
print(type("IMT Atlantique"))

# Result of a computation beetween integers
result = 456 * 10^9
print(type(result))

# Reals
val = -87.56
print(type(val))

/**
 * To run this code, you need to have Java installed on your computer, then:
 * - Create a file named `Main.java` in a directory of your choice.
 * - Copy this code in the file.
 * - Open a terminal in the directory where the file is located.
 * - Run the command `javac Main.java` to compile the code.
 * - Run the command `java -ea Main` to execute the compiled code.
 * Note: '-ea' is an option to enable assertions in Java.
 */
public class Main {

    /**
     * This is the entry point of your program.
     * It contains the first codes that are going to be executed.
     *
     * @param args Command line arguments received.
     */
    public static void main(String[] args) {
        // Booleans
        boolean b = true;
        System.out.println(((Object) b).getClass().getName());

        // Integers
        int i = -35;
        System.out.println(((Object) i).getClass().getName());

        // Characters
        char new_line = '\n';
        System.out.println(((Object) new_line).getClass().getName());

        // Strings
        System.out.println(((Object) "IMT Atlantique").getClass().getName());

        // Result of a computation between integers
        int result = 456 * 10 ^ 9;
        System.out.println(((Object) result).getClass().getName());

        // Reals
        float val = -87.56f;
        System.out.println(((Object) val).getClass().getName());
    }
}

<class 'bool'>
<class 'int'>
<class 'str'>
<class 'str'>
<class 'int'>
<class 'float'>

java.lang.Boolean
java.lang.Integer
java.lang.Character
java.lang.String
java.lang.Integer
java.lang.Float

3 — Opérateurs

3.1 — Sur les valeurs numériques

Le type d’une valeur ou d’une variable détermine les opérations qui peuvent lui être appliquées.
Sur les valeurs numériques, c’est-à-dire entiers et réels, les opérateurs arithmétiques avec leurs priorités classiques peuvent être appliqués :

# Addition
v = 12 + 3.3

# Multiplication
v = 1.5 * 2

# Division and floor division
v = 4.12 / 1.5 // 2

# Exponentiation
v = 3.2 ** 2

# Modulo, rest of the Euclidean division
v = 3762 % 6

// Needed imports
import java.lang.Math;

/**
 * To run this code, you need to have Java installed on your computer, then:
 * - Create a file named `Main.java` in a directory of your choice.
 * - Copy this code in the file.
 * - Open a terminal in the directory where the file is located.
 * - Run the command `javac Main.java` to compile the code.
 * - Run the command `java -ea Main` to execute the compiled code.
 * Note: '-ea' is an option to enable assertions in Java.
 */
public class Main {

    /**
     * This is the entry point of your program.
     * It contains the first codes that are going to be executed.
     *
     * @param args Command line arguments received.
     */
    public static void main(String[] args) {
        // Addition
        double a = 12 + 3.3;

        // Multiplication
        double m = 1.5 * 2;

        // Division and floor division
        double d = Math.floor(4.12 / 1.5 / 2);

        // Exponentiation
        double e = Math.pow(3.2, 2);

        // Modulo, rest of the Euclidean division
        double mo = 3762 % 6;
    }

}

3.2 — Sur les booléens

Les valeurs booléennes peuvent être combinées à l’aide des opérateurs de l’algèbre de Boole : conjonction (and), disjonction (or) et négation (not).
L’opérateur de négation transforme true en false et vice versa.
La table de vérité des opérateurs conjonctif et disjonctif est donnée ci-dessous.

L’algèbre de Boole est une pièce centrale de nombreuses instructions algorithmiques et vous aurez souvent à exprimer des expressions booléennes complexes.
Les lois de De Morgan sont deux règles de transposition qui peuvent être très utiles pour déterminer la négation d’expressions booléennes complexes.
Voici ces deux règles :

• not(A and B) == not(A) or not(B)
• not(A or B) == not(A) and not(B)

Les opérateurs de comparaison interviennent dans la construction des conditions pour donner une valeur booléenne.
Ils sont les mêmes pour Python et Java :

• == pour tester l’égalité et != pour l’inégalité.
• <, >, <=, >= pour les comparaisons supérieures/inférieures.

3.3 — Autres types simples

Il existe de nombreux opérateurs définis sur d’autres types de données.
Par exemple, dans de nombreux langages de programmation, l’opérateur + peut être utilisé pour concaténer des chaînes de caractères.
De même, [] peut être utilisé pour accéder à un élément ou une sous-chaîne d’une chaîne donnée.

En général, lorsque vous souhaitez effectuer des opérations simples sur un type de données de base, il existe un opérateur pour cela, n’hésitez donc pas à consulter la cheatsheet ici.

4 — Types mutables et immutables

Lié à l’idée de valeurs modifiables ou non modifiables, il y a le concept de “mutabilité”.
La mutabilité est une propriété associée au type d’une valeur, donc au type d’une variable/constante.

• Si une variable/constante est associée à une valeur “mutable”, cela signifie que son contenu peut être modifié pendant l’exécution du code.
• Si une variable/constante est associée à une valeur “immutable”, cela signifie que son contenu ne peut pas être modifié pendant l’exécution du code, et toute tentative de modification entraînera une erreur ou la création d’une nouvelle variable pour stocker la nouvelle valeur.

Selon le langage de programmation, les types de données sont soit mutables soit immutables.
En Python, par exemple, les listes et dictionnaires sont mutables, ce qui signifie que l’on peut changer leur contenu sans avoir à créer une nouvelle variable.
Au contraire, les tuples, entiers ou chaînes sont immutables.
Vérifiez la mutabilité de chaque type de données !

Pour aller plus loin

On dirait que cette section est vide !

Y a-t-il quelque chose que vous auriez aimé voir ici ?
Faites-le nous savoir sur le serveur Discord !
Peut-être pourrons-nous l’ajouter rapidement.
Sinon, cela nous aidera à améliorer le cours pour l’année prochaine !

Pour aller au-delà

• Collection data types in Python.

  Un article avec une description approfondie des différentes structures de données disponibles en Python.

• Collections in Java.

  Même chose pour Java.