| Les deux révisions précédentes Révision précédente Prochaine révision | Révision précédente |
| info:prog:varop [2025/06/16 19:01] – [Modifier - Pane] mno | info:prog:varop [2025/06/19 19:29] (Version actuelle) – modification externe 127.0.0.1 |
|---|
| | [[info:accueilinfo|{{ :iconemaison.jpg?nolink&25|Sommaire "Bases d'algorithmique et de programmation"}}]] |
| | |
| | ===== Variables, constantes et opérateurs ===== |
| | [Mise à jour le : 16/6/2025] |
| | |
| | <html><span style="color:red">En cours de rédaction</span></html> |
| | |
| | <callout icon="fa fa-wrench" color="blue" title="Mots-clés">programme, donnée, mémoire, variable, déclarer, initialiser, portée, opérateurs, arithmétique, logique, comparaison.</callout> |
| | |
| | ==== 1. Les variables ==== |
| | <callout type="info" icon="true">Pendant l'exécution d'un **programme**, les **données** qu'il traite sont stockées en **mémoire**. Les **variables** permettent de manipuler ces données sans se préoccuper de leur position. Pour cela, il suffit de leur donner un nom (les **déclarer**).</callout> |
| | \\ |
| | === 1.1 Nommage === |
| | <callout type="primary" icon="true"> Une variable doit respecter quelques **règles de syntaxe**. </callout> |
| | |
| | <tabs> |
| | * [[#tab-python1|Python]] |
| | * [[#tab-cpp1|C, C++ (Arduino)]] |
| | * [[#tab-js1|JavaScript]] |
| | * [[#tab-php1|PHP]] |
| | * [[#tab-cs1|C#]] |
| | |
| | <pane id="tab-python1"> |
| | <callout type="warning" icon="true"> En Python, le nom d'une variable ne peut être composé que de **lettres**, de **chiffres** et de underscore "**_**". Le nom d'une variable ne peut pas commencer par un chiffre. Python est **sensible à la casse** (position ≠ Position). Les espaces et caractères spéciaux ne sont pas autorisés. L'**usage** veut qu'on se limite à des caractères minuscules <html><a href="https://wprock.fr/blog/conventions-nommage-programmation/" target="_blank">underscore case</a></html> !</callout> |
| | </pane> |
| | |
| | <pane id="tab-cpp1"> |
| | <callout type="warning" icon="true"> |
| | En C, C++ (Arduino), le nom d'une variable ne peut être composé que de **lettres**, de **chiffres** et de underscore "**_**". Le nom d'une variable doit commencer par une lettre. C, C++ (Arduino) sont **sensibles à la casse** (position ≠ Position). |
| | </callout> |
| | </pane> |
| | |
| | <pane id="tab-js1"> |
| | <callout type="warning" icon="true"> |
| | En JavaScript le nom d'une variable commence par une **lettre** ou par **$**. JavaScript est **sensible à la casse** (position ≠ Position). |
| | </callout> |
| | </pane> |
| | |
| | <pane id="tab-php1"> |
| | <callout type="warning" icon="true"> |
| | En PHP un nom de variable doit commencer par par **$**. Un nom de variable peut comporter des lettres, des chiffres et le caractère underscore "**_**". Les espaces ne sont pas autorisés! PHP est **sensible à la casse**. |
| | </callout> |
| | </pane> |
| | |
| | <pane id="tab-cs1"> |
| | <callout type="warning" icon="true"> |
| | En C#, le nom d'une variable ne peut être composé que de **lettres**, de **chiffres** et de underscrore "**_**". Le nom d'une variable doit commencer par une lettre ou un underscore (_). Les espaces et les caractères spéciaux ne sont pas autorisés. C# est **sensibles à la casse** (maVariable ≠ MaVariable). |
| | </callout> |
| | </pane> |
| | |
| | </tabs> |
| | \\ |
| | === 1.2 Déclaration et initialisation === |
| | <callout type="info" icon="true">Pour **exister**, une variable doit être **déclarée**.</callout> |
| | |
| | * **Algorithmique** |
| | <callout icon="fa fa-align-justify"> |
| | **var** \\ |
| | variable1 : type <nowiki>//</nowiki> //Déclaration de variable1, variable2 et variable 3//\\ |
| | variable2, variable3 : type \\ |
| | variable4 <- valeur <nowiki>//</nowiki> //Initialisation de variable4 avec valeur//\\ |
| | </callout> |
| | |
| | * **Programmation** |
| | |
| | <tabs> |
| | * [[#tab-python2|Python]] |
| | * [[#tab-cpp2|C, C++ (Arduino)]] |
| | * [[#tab-js2|JavaScript]] |
| | * [[#tab-php2|PHP]] |
| | * [[#tab-cs2|C#]] |
| | |
| | <pane id="tab-python2"> |
| | <callout type="warning" icon="true"> |
| | En Python, la simple **déclaration** d'une variable ne suffit pas à la créer. Après avoir choisi son nom, il est nécessaire de lui **affecter** une **valeur initiale (initialisation)**. Dans ce langage l'affectation s'effectue avec le symbole "**=**". |
| | \\ \\ |
| | //Remarque// : Python ne propose pas de constantes strictes, mais par convention, les noms des constantes sont en majuscules (PI = 3.14159). |
| | </callout> |
| | |
| | //Exemple// |
| | <code python .py> |
| | position_x = 10 # variable de type entier nommée selon la convention inderscore case |
| | pi = 1.14159 # variable de type réel |
| | hello = "Hello world !" # variable de type chaîne de caractère |
| | |
| | # Déclaration et initialisation multiple possible ! |
| | position_x, pi, hello = 10, 1.14159, "Hello world !" |
| | |
| | </code> |
| | </pane> |
| | |
| | <pane id="tab-cpp2"> |
| | <callout type="warning" icon="true"> |
| | En C, C++ (Arduino), on déclare une variable en précisant son **type**, suivi d'un **espace** puis son **nom**. La déclaration se termine par un **point-virgule**. |
| | </callout> |
| | |
| | <code cpp .cpp> |
| | // Déclaration |
| | int noteDeMaths; |
| | double sommeArgentRecue; |
| | unsigned int nombreDeLecteursEnTrainDeLireUnNomDeVariableUnPeuLong; |
| | |
| | // Déclaration et affectation |
| | char lettre='B'; |
| | </code> |
| | </pane> |
| | |
| | <pane id="tab-js2"> |
| | <callout type="warning" icon="true"> |
| | En JavaScript, la déclaration et l'utilisation des variables sont assez souples grâce à son typage dynamique et ses différentes façons de déclarer des variables. Il est possible, mais pas obligatoire d’initialiser une variable (lui attribuer une valeur) lors de sa déclaration. |
| | * Mots-clés de déclaration : |
| | * **var** : ancienne méthode, avec une portée fonctionnelle. |
| | * **let** : permet de déclarer des variables avec une portée de bloc. |
| | * **const** : pour les variables dont la valeur ne change pas après l'affectation. \\ //Remarque// : une constante ne peut pas être réaffectée, mais son contenu (comme un objet) peut être modifié. |
| | </callout> |
| | |
| | <code js .js> |
| | // Déclaration |
| | var i ; |
| | |
| | // Déclaration et initialisation |
| | var etat = true : // type booléen |
| | var $Somme = 400; // type entier |
| | var maMoyenneEnTsin = 12.5 ; // type nombre réel |
| | var monPrenom = "Lucas" ; // type chaine de caractères |
| | if (true) { |
| | let y = 5; // y est seulement connu dans le bloc if |
| | } |
| | |
| | // Déclaration et initialisation multiple possible ! |
| | let [x, y, z] = [10, 20, 30]; |
| | |
| | // Constante |
| | const PI = 3.14159; // Constante |
| | </code> |
| | </pane> |
| | |
| | <pane id="tab-php2"> |
| | <callout type="warning" icon="true"> |
| | En PHP, les variables ont une syntaxe simple et flexible grâce à son typage dynamique. Aucune déclaration de type (int, string, bool, etc.) n'est nécessaire. \\ \\ |
| | //Remarque// : une constante est déclarée avec **define**("NOM", valeur); ou **const** NOM **=** valeur;. |
| | </callout> |
| | |
| | //Exemple// |
| | <code php *.php> |
| | $nom = "Bob"; |
| | $age = 25; |
| | $estActif = true; |
| | define("PI", 3.14159); |
| | </code> |
| | </pane> |
| | |
| | <pane id="tab-cs2"> |
| | <callout type="warning" icon="true"> |
| | En C#, une variable peut être **déclarée sans être initialisée**, mais elle doit l'être avant d'être utilisée pour éviter une erreur de compilation. L'utilisation de **var** permet au compilateur de déduire automatiquement le type de la variable à partir de la valeur affectée. \\ \\ |
| | //Remarque// : une variable déclarée avec **const** ne peut pas être modifiée après l'initialisation. |
| | </callout> |
| | |
| | //Exemple// |
| | <code csharp *.cs> |
| | // Déclaration |
| | int age; |
| | |
| | // Déclaration et initialisation |
| | string nom = "Bob"; |
| | bool estActif = true; |
| | const double PI = 3.14159; |
| | var message = "Bonjour !"; |
| | |
| | // Constante |
| | const double PI = 3.14159; |
| | </code> |
| | </pane> |
| | </tabs> |
| | \\ |
| | === 1.3 Types === |
| | <callout type="info" icon="true">Le **type d'une variable** identifie la **nature de son contenu** : nombre entier, nombre décimal, texte, etc.. Ces différents types d'information peuvent être placés dans une variable. </callout> |
| | |
| | * **Programmation** |
| | <tabs> |
| | * [[#tab-python3|Python]] |
| | * [[#tab-cpp3|C, C++ (Arduino)]] |
| | * [[#tab-js3|JavaScript]] |
| | * [[#tab-php3|PHP]] |
| | * [[#tab-cs3|C#]] |
| | |
| | <pane id="tab-python3"> |
| | * **Source** : <html><a href="https://docs.python.org/fr/3.7/library/stdtypes.html#built-in-types" target="_blank">Types natifs</a></html> |
| | |
| | <callout type="info" icon="true"> En Python, il n'est pas nécessaire de préciser le type d'une variable. Python est dit : "**typé dynamiquement**". </callout> |
| | |
| | * Les principaux types sont : \\ |
| | * Les entiers (**int**) \\ |
| | * Les décimaux (**float**) \\ |
| | * Les nombres complexes (**complex**) \\ |
| | * Les booléens (**bool**), sous-ensemble des entiers \\ |
| | * Les chaînes de caractères (**str**) \\ |
| | * Les listes (**list**) \\ |
| | |
| | <callout type="tip" icon="true"> Les entiers sont donnés sans **perte de précision**. </callout> |
| | |
| | * **Connaître** le type d'une variable avec **type**() et **isinstance**(). |
| | |
| | //Exemple// |
| | <code python exvar2a.py> |
| | nom_variable = 15 |
| | type(nom_variable) # renvoie <class 'int'> dans la console |
| | isinstance(nom_variable,int) # renvoie true |
| | type(4+5j) # renvoie <class 'complex'> |
| | </code> |
| | |
| | * **Convertir** une **chaîne de caractères** en un entier avec **//int()//** |
| | |
| | //Exemple// |
| | <code python exvar2b.py> |
| | annee = "2019" # renvoie la chaîne de caractères '2019' dans la console |
| | annee = int(annee) # renvoie le nombre 2019 dans la console |
| | </code> |
| | |
| | * **Convertir** un **entier** en une chaîne de caractères **//str()//** |
| | |
| | //Exemple// |
| | <code python exvar2c.py> |
| | annee = 2019 # renvoie le nombre 2019 dans la console |
| | annee = str(annee) # renvoie la chaîne de caractères '2019' |
| | </code> |
| | \\ |
| | * **float()** : permet la transformation en flottant. |
| | \\ |
| | * **long()** : transforme une valeur en long. |
| | |
| | </pane> |
| | |
| | <pane id="tab-cpp3"> |
| | <callout type="info" icon="true"> |
| | A faire |
| | </callout> |
| | </pane> |
| | |
| | <pane id="tab-js3"> |
| | <callout type="info" icon="true"> |
| | Le Javascript dispose actuellement de **7 types** de données dont 6 sont dits **primitifs**: |
| | * **Number** (les nombres), |
| | * **String** (les chaînes de caractères), |
| | * **Boolean** (les booléens), **Null** (rien), |
| | * **undefined** (pas défini) et |
| | * **Symbol** (disponible depuis ES6), |
| | plus le type |
| | * **Object** (Objet, peut contenir plusieurs variables de type différents). |
| | </callout> |
| | </pane> |
| | |
| | <pane id="tab-php3"> |
| | <callout type="info" icon="true"> |
| | A faire |
| | </callout> |
| | </pane> |
| | |
| | <pane id="tab-cs3"> |
| | <callout type="info" icon="true"> |
| | A faire |
| | </callout> |
| | </pane> |
| | </tabs> |
| | \\ |
| | === 1.4 Copie === |
| | <callout type="info" icon="true"> Le contenu d'une variable //var1// peut être placé dans une variable //var2//.</callout> |
| | |
| | <tabs> |
| | * [[#tab-python4|Python]] |
| | * [[#tab-cpp4|C, C++ (Arduino)]] |
| | * [[#tab-js4|JavaScript]] |
| | * [[#tab-php4|PHP]] |
| | * [[#tab-cs4|C#]] |
| | |
| | <pane id="tab-python4"> |
| | //Exemple// |
| | |
| | <code python exvar3.py> |
| | var2 = var1 |
| | </code> |
| | </pane> |
| | |
| | <pane id="tab-cpp4"> |
| | A faire |
| | </pane> |
| | |
| | <pane id="tab-js4"> |
| | A faire |
| | </pane> |
| | |
| | <pane id="tab-php4"> |
| | A faire |
| | </pane> |
| | |
| | <pane id="tab-cs4"> |
| | A faire |
| | </pane> |
| | </tabs> |
| | \\ |
| | === 1.5 Permutation === |
| | |
| | <callout type="info" icon="true"> Une permutation consiste à **intervertir** les valeurs de deux variables </callout> |
| | |
| | <tabs> |
| | * [[#tab-python5|Python]] |
| | * [[#tab-cpp5|C, C++ (Arduino)]] |
| | * [[#tab-js5|JavaScript]] |
| | * [[#tab-php5|PHP]] |
| | * [[#tab-cs5|C#]] |
| | |
| | <pane id="tab-python5"> |
| | <callout type="tip" icon="true"> |
| | **Python** propose un moyen simple pour permuter deux variables (échanger leur valeur). |
| | </callout> |
| | |
| | //Exemple// |
| | <code python exvar4.py> |
| | a = 5 |
| | b = 32 |
| | a,b = b,a # résultat a = 32, b = 5 |
| | </code> |
| | </pane> |
| | |
| | <pane id="tab-cpp5"> |
| | A faire |
| | </pane> |
| | |
| | <pane id="tab-js5"> |
| | A faire |
| | </pane> |
| | |
| | <pane id="tab-php5"> |
| | A faire |
| | </pane> |
| | |
| | <pane id="tab-cs5"> |
| | A faire |
| | </pane> |
| | </tabs> |
| | \\ |
| | === 1.6 Variable sans valeur === |
| | <callout type="info" icon="true">On peut **réinitialiser** une variable en l'affectant d'une valeur **vide** avec le mot **//None//**. </callout> |
| | |
| | \\ |
| | === 1.7 Portée === |
| | <callout type="info" icon="true"> La **portée** d'une variable est la portion de code source où elle est accessible. </callout> |
| | |
| | <tabs> |
| | * [[#tab-python7|Python]] |
| | * [[#tab-cpp7|C, C++ (Arduino)]] |
| | * [[#tab-js7|JavaScript]] |
| | * [[#tab-php7|PHP]] |
| | * [[#tab-cs7|C#]] |
| | |
| | <pane id="tab-python7"> |
| | <callout type="warning" icon="true"> |
| | Pour connaître la portée d'une variable on utilise la règle **LEGB** : \\ **L**ocalement (variable déclarée dans une fonction) \\ **E**nglobante (variable déclarée dans une fonction qui contient la fonction où elle est appelée) \\ **G**lobalement (variable déclarée globalement) \\ **B**uiltins (est une variable Built-in) |
| | </callout> |
| | |
| | * **Espace local** |
| | <callout type="primary" icon="true"> Les variables définies dans un corps de fonction ou passées en paramètres sont seulement accessibles dans le corps de la fonction. </callout> |
| | //Exemple// |
| | |
| | <code python *.py> |
| | |
| | # Espace local au programme |
| | valext = 5 # variable connue dans et hors de la fonction |
| | |
| | def func(valint): # ici valint <- valext, valint : variable connue seulement dans la fonction |
| | # Espace local à la fonction func |
| | valint = valint * 2 |
| | # valext est connue de func bien que sa déclaration soit à l'extérieure |
| | print("Dans la fonction func, valext = ", valext) |
| | # REMARQUES |
| | # valint = valext * 2 est possible, mais déconseillé par les bonnes pratiques de programmation |
| | # valext = valext * 2 est INTERDIT, car on ne peut pas modifier une variable extérieure à l'espace local |
| | print("Dans la fonction func, valint * 2 = ", valint," car valint <- valext lors de l'appel") |
| | return valint |
| | |
| | print("Avant l'appel de func, valext = ", valext) |
| | valext = func(valext) # valext est connue de func bien que sa déclaration soit à l'extérieure |
| | print("Après l'appel de func et l'opération valext = func(valext), valext = ", valext) |
| | print(valint) # valint n'est pas connue à l'extérieure de func |
| | |
| | # Résultat attendu |
| | # Avant l'appel de func, valext = 5 |
| | # Dans la fonction func, valext = 5 |
| | # Dans la fonction func, valint * 2 = 10 |
| | # Après l'appel de func et l'opération valext = func(valext), valext = 10 car valint <- valext lors de l'appel |
| | # Une exception s'est produite : NameError |
| | # name 'valint' is not defined |
| | </code> |
| | <callout type="danger" icon="true"> Une fonction ne peut pas modifier la valeur d'une variable extérieure à son espace local par une affectation. </callout> |
| | |
| | * **Variable globale** |
| | <callout type="danger" icon="true"> Pour modifier une variable extérieure à une fonction, on la qualifie de **globale**. </callout> |
| | |
| | //Exemple// |
| | |
| | <code python *.py> |
| | # Espace local au programme |
| | valext = 5 # variable connue dans et hors de la fonction |
| | |
| | def func(): # ici valint <- valext, valint : variable connue seulement dans la fonction |
| | # Espace local à la fonction func |
| | global valext # A éviter sauf cas particulier |
| | return valext * 2 |
| | |
| | print("Après l'appel de func, valext = ", func()) |
| | </code> |
| | </pane> |
| | |
| | <pane id="tab-cpp7"> |
| | <callout type="warning" icon="true"> |
| | A faire |
| | </callout> |
| | </pane> |
| | |
| | <pane id="tab-js7"> |
| | <callout type="warning" icon="true"> |
| | A faire |
| | </callout> |
| | </pane> |
| | |
| | <pane id="tab-php7"> |
| | <callout type="warning" icon="true"> |
| | A faire |
| | </callout> |
| | </pane> |
| | |
| | <pane id="tab-cs7"> |
| | <callout type="warning" icon="true"> |
| | A faire |
| | </callout> |
| | </pane> |
| | </tabs> |
| | \\ |
| | ==== 2. Les opérateurs et les calculs ==== |
| | |
| | === 2.1 L'affectation === |
| | <callout type="info" icon="true"> En algorithmique et en programmation informatique, une affectation, aussi appelée **assignation** (anglicisme), est une structure qui permet d'**attribuer une valeur à une variable**. <html><a href="https://fr.wikipedia.org/wiki/Affectation_(informatique)" target="_blank">Wikipédia</a></html> \\ |
| | \\ |
| | En algorithmique, on utilise le symbole flèche : ** <- |
| | ** \\ |
| | \\ |
| | //Exemple// \\ |
| | variable <- 15 \\ |
| | \\ |
| | Les langages ci-dessous utilisent le signe **=** pour affecter une valeur à une variable. |
| | </callout> |
| | |
| | <tabs> |
| | * [[#tab-python0|Python]] |
| | * [[#tab-cpp0|C, C++ (Arduino)]] |
| | * [[#tab-js0|JavaScript]] |
| | * [[#tab-php0|PHP]] |
| | * [[#tab-cs0|C#]] |
| | |
| | <pane id="tab-python0"> |
| | * **Source** : <html><a href="https://python-reference.readthedocs.io/en/latest/docs/operators/index.html#assignment-operators" target="_blank">Assignment Operators</a></html> \\ |
| | </pane> |
| | |
| | <pane id="tab-cpp0"> |
| | * * **Source** : <html><a href="https://fr.wikiversity.org/wiki/Langage_C%2B%2B/Op%C3%A9rateurs#Op%C3%A9rateurs_d'affectation" target="_blank">Opérateurs d'affectation</a></html> \\ |
| | </pane> |
| | |
| | <pane id="tab-js0"> |
| | * **Source** : <html><a href="https://developer.mozilla.org/fr/docs/Web/JavaScript/Guide/Expressions_and_Operators" target="_blank">Expressions et opérateurs</a></html> \\ |
| | </pane> |
| | |
| | <pane id="tab-php0"> |
| | * **Source** : <html><a href="https://www.php.net/manual/fr/language.operators.assignment.php" target="_blank">Les opérateurs d'affectation</a></html> \\ |
| | </pane> |
| | |
| | <pane id="tab-cs0"> |
| | * **Source** : <html><a href="https://docs.microsoft.com/fr-fr/dotnet/csharp/language-reference/operators/" target="_blank">Opérateurs et expressions c# (référence C#)</a></html> \\ |
| | </pane> |
| | </tabs> |
| | \\ |
| | === 2.2 Les opérateurs arithmétiques === |
| | <callout type="info" icon="true"> Dans un algorithme, on écrira : |
| | <grid> |
| | <col sm="1">addition \\ **+** </col> |
| | <col sm="1">soustraction \\ **-**</col> |
| | <col sm="1">multiplication \\ ***** ou **x**</col> |
| | <col sm="1">division euclid. \\ **/**</col> |
| | <col sm="1">division entière \\ **DIV**</col> |
| | <col sm="1">reste division \\ ** % ** ou **mod** </col> |
| | <col sm="1">x puissance n \\ ** x<sup>n</sup> ** </col> |
| | <col sm="1">etc.</col> |
| | </grid> |
| | </callout> |
| | |
| | <tabs> |
| | * [[#tab-python8|Python]] |
| | * [[#tab-cpp8|C, C++ (Arduino)]] |
| | * [[#tab-js8|JavaScript]] |
| | * [[#tab-php8|PHP]] |
| | * [[#tab-cs8|C#]] |
| | |
| | <pane id="tab-python8"> |
| | * **Source** : <html><a href="https://python-reference.readthedocs.io/en/latest/docs/operators/index.html#arithmetic-operators" target="_blank">Arithmetic Operators</a></html> \\ |
| | |
| | <callout type="warning" icon="true"> En Python, on utilise : \\ |
| | - ***** pour la multiplication, \\ |
| | - **<nowiki>**</nowiki>** pour la puissance, \\ |
| | - **<nowiki>//</nowiki>** pour la division entière et \\ |
| | - **%** pour le reste de la division. |
| | </callout> |
| | |
| | * //Exemple sur des entiers// |
| | <code python exvar5a.py> |
| | var1 = 5 |
| | var2 = 1 |
| | var3 = var1 + var2 # résultat var3 = 6 |
| | </code> |
| | \\ |
| | * //Exemple sur des flottants// |
| | <code python - exvar5b.py> |
| | var1 = 5.2 |
| | var2 = 1.4 |
| | var3 = var1 + var2 # résultat var3 = 6.6 |
| | </code> |
| | </pane> |
| | |
| | <pane id="tab-cpp8"> |
| | * **Source** : <html><a href="https://fr.wikiversity.org/wiki/Langage_C%2B%2B/Op%C3%A9rateurs#Les_op%C3%A9rateurs_math%C3%A9matiques" target="_blank">Les opérateurs mathématiques</a></html> \\ |
| | </pane> |
| | |
| | <pane id="tab-js8"> |
| | * **Source** : <html><a href="https://developer.mozilla.org/fr/docs/Web/JavaScript/Guide/Expressions_and_Operators#op%c3%a9rateurs_arithm%c3%a9tiques" target="_blank">Opérateurs arithmétiques</a></html> \\ |
| | </pane> |
| | |
| | <pane id="tab-php8"> |
| | * **Source** : <html><a href="https://www.php.net/manual/fr/language.operators.arithmetic.php" target="_blank">Les opérateurs arithmétiques</a></html> \\ |
| | </pane> |
| | |
| | <pane id="tab-cs8"> |
| | * **Source** : <html><a href="https://docs.microsoft.com/fr-fr/dotnet/csharp/language-reference/operators/arithmetic-operators" target="_blank">Opérateurs arithmétiques (référence C#)</a></html> \\ |
| | </pane> |
| | </tabs> |
| | \\ |
| | === 2.3 Les opérateurs booléens === |
| | <callout type="info" icon="true"> Les variables booléennes prennent les valeurs **VRAI** et **FAUX** ou **1** et **0**. \\ Dans un algorithme, on écrira : \\ |
| | <grid> |
| | <col sm="1">Conjonction \\ **ET** </col> |
| | <col sm="1">Disjonction \\ **OU** </col> |
| | <col sm="1">Négation \\ **NON** </col> |
| | </grid> |
| | </callout> |
| | |
| | <tabs> |
| | * [[#tab-python9|Python]] |
| | * [[#tab-cpp9|C, C++ (Arduino)]] |
| | * [[#tab-js9|JavaScript]] |
| | * [[#tab-cs9|C#]] |
| | |
| | <pane id="tab-python9"> |
| | * **Sources** |
| | * <html><a href="https://python-reference.readthedocs.io/en/latest/docs/operators/index.html#boolean-operators" target="_blank">Opérateurs booléens</a></html> |
| | * <html><a href="https://realpython.com/python-not-operator/" target="_blank">Using the "not" Boolean Operator in Python</a></html> |
| | * <html><a href="https://realpython.com/python-and-operator/" target="_blank">Using the "and" Boolean Operator in Python</a></html> |
| | * <html><a href="https://realpython.com/python-or-operator/" target="_blank">Using the "or" Boolean Operator in Python</a></html> |
| | |
| | <callout type="warning" icon="true">En Python, **and** est la conjonction, **or** la disjonction et **not** la négation.</callout> |
| | |
| | //Exemples// |
| | <code python exvar6a.py> |
| | bool1, bool2 = True, False |
| | bool3, bool4 = 1, 0 |
| | bool5 = bool1 and bool2 # résultat : bool5 = False |
| | bool5 = bool1 or bool2 # résultat : bool6 = True |
| | bool7 = not(bool1) # résultat : bool7 = False |
| | bool8 = bool3 & bool4 # résultat : bool8 = 0 |
| | </code> |
| | </pane> |
| | |
| | <pane id="tab-cpp9"> |
| | * **Source** : <html><a href="https://fr.wikiversity.org/wiki/Langage_C%2B%2B/Op%C3%A9rateurs#Les_op%C3%A9rateurs_logiques" target="_blank">Les opérateurs logiques</a></html> \\ |
| | </pane> |
| | |
| | <pane id="tab-js9"> |
| | * **Source** : <html><a href="https://developer.mozilla.org/fr/docs/Web/JavaScript/Guide/Expressions_and_Operators#op%c3%a9rateurs_logiques" target="_blank">Opérateurs logiques</a></html> \\ |
| | </pane> |
| | |
| | <pane id="tab-cs9"> |
| | * **Source** : <html><a href="https://docs.microsoft.com/fr-fr/dotnet/csharp/language-reference/operators/boolean-logical-operators" target="_blank">Opérateurs logiques booléens (référence C#)</a></html> \\ |
| | </pane> |
| | </tabs> |
| | \\ |
| | === 2.4 Les opérateurs de comparaison === |
| | <callout type="info" icon="true"> Un opérateur de comparaison compare ses deux opérandes et renvoie un valeur booléenne correspondant au résultat de la comparaison (vraie ou fausse). Les opérandes peuvent être des nombres, des chaînes de caractères, des booléens ou des objets. </callout> |
| | |
| | <tabs> |
| | * [[#tab-python10|Python]] |
| | * [[#tab-cpp10|C, C++ (Arduino)]] |
| | * [[#tab-js10|JavaScript]] |
| | * [[#tab-cs10|C#]] |
| | |
| | <pane id="tab-python10"> |
| | * **Source** : <html><a href="https://python-reference.readthedocs.io/en/latest/docs/operators/index.html#relational-operators" target="_blank">Opérateurs relationnels</a></html> \\ |
| | </pane> |
| | |
| | <pane id="tab-cpp10"> |
| | * **Source** : <html><a href="https://fr.wikiversity.org/wiki/Langage_C%2B%2B/Op%C3%A9rateurs#Les_op%C3%A9rateurs_comparatifs" target="_blank">Les opérateurs comparatifs</a></html> \\ |
| | </pane> |
| | |
| | <pane id="tab-js10"> |
| | * **Source** : <html><a href="https://developer.mozilla.org/fr/docs/Web/JavaScript/Guide/Expressions_and_Operators#op%c3%a9rateurs_de_comparaison" target="_blank">Opérateurs de comparaison</a></html> \\ |
| | </pane> |
| | |
| | <pane id="tab-cs10"> |
| | * **Source** : <html><a href="https://docs.microsoft.com/fr-fr/dotnet/csharp/language-reference/operators/comparison-operators" target="_blank">Opérateurs de comparaison (référence C#)</a></html> \\ |
| | </pane> |
| | </tabs> |
| | \\ |
| | |
| | === 2.5 Les opérateurs de niveau bit === |
| | <callout type="info" icon="true"> En logique, une **opération bit à bit** est un calcul manipulant les données directement au niveau des bits, selon une arithmétique booléenne. Elles sont utiles dès qu'il s'agit de manipuler les données à bas niveau : codages, couches basses du réseau (par exemple TCP/IP), cryptographie,etc. <html><a href="https://fr.wikipedia.org/wiki/Op%C3%A9ration_bit_%C3%A0_bit" target="_blank">Wikipédia</a></html> </callout> |
| | |
| | <tabs> |
| | * [[#tab-python11|Python]] |
| | * [[#tab-cpp11|C, C++ (Arduino)]] |
| | * [[#tab-js11|JavaScript]] |
| | * [[#tab-cs11|C#]] |
| | |
| | <pane id="tab-python11"> |
| | * **Source** : <html><a href="https://python-reference.readthedocs.io/en/latest/docs/operators/index.html#bitwise-operators" target="_blank">Bitwise Operators</a></html> \\ |
| | \\ |
| | <grid> |
| | <col sm="1">ET \\ **&** </col> |
| | <col sm="1">OU \\ **|**</col> |
| | <col sm="1">NON \\ **~** </col> |
| | <col sm="1">OU EXCLUSIF \\ **^**</col> |
| | <col sm="1">Décalage à GAUCHE \\ **<<**</col> |
| | <col sm="1">Décalage à DROITE \\ ** >> **</col> |
| | </grid> |
| | //Exemples// |
| | <code python exvar6b.py> |
| | # 0b précise que le nombre qui suit est exprimé en binaire |
| | var1 = 0b01010101 # résultat var1 = 85 en base 10 |
| | var2 = 0b10101010 # résultat var2 = 170 en base 10 |
| | var3 = var1 & var2 # résultat var3 = 0 en base 10, bin(var3) = 0b00000000 |
| | var4 = var1 | var2 # résultat var4 = 255 en base 10, bin(var4) = 0b11111111 |
| | var5 = ~var1 # résultat var5 = -86 en base 10 car l'ordinateur calcule en complément à 2 |
| | # or 2**n + complément à 2 de x = x ici = = 8 donc 256-86 = 170 = 0b10101010 = var2 |
| | var6 = var1 ^ bool2 # résultat bin(var6) = 0b11111111 |
| | var7 = var1 << 1 # résultat var7 = 170 (décalage à gauche de 1 => multiplication entière par 2) |
| | var8 = var2 >> 1 # résultat var8 = 85 (décalage à droite de 1 => division entière par 2) |
| | </code> |
| | |
| | * **Base 2, 10, 16** |
| | Par défaut, les nombres entiers saisis ou affichés sont en base 10. |
| | |
| | <callout type="info" icon="true">Pour manipuler des séquences de bits, de longueur arbitraire on utilise **0b** devant la valeur binaire ou **0x** devant la valeur hexadécimale.La fonction **bin**(**n**) renvoie la valeur de n en binaire. La fonction **hex**(**n**) renvoie la valeur de n en hexadécimale. Ces fonctions renvoient des chaînes de caractères.</callout> |
| | |
| | //Exemples// |
| | <code python exvar6c.py> |
| | bin(43) # renvoie '0b101011' |
| | bin(0xf4) # '0b11110100' |
| | hex(43) # '0x2b' |
| | hex(0b11110100) # '0xf4' |
| | </code> |
| | </pane> |
| | |
| | <pane id="tab-cpp11"> |
| | * **Source** : <html><a href="https://fr.wikiversity.org/wiki/Langage_C%2B%2B/Op%C3%A9rateurs#Op%C3%A9rateurs_bit_%C3%A0_bit" target="_blank">Opérateurs bit à bit</a></html> \\ |
| | </pane> |
| | |
| | <pane id="tab-js11"> |
| | * **Source** : <html><a href="https://developer.mozilla.org/fr/docs/Web/JavaScript/Guide/Expressions_and_Operators#op%c3%a9rateurs_binaires" target="_blank">Opérateurs binaires</a></html> \\ |
| | </pane> |
| | |
| | <pane id="tab-cs11"> |
| | * **Source** : <html><a href="https://docs.microsoft.com/fr-fr/dotnet/csharp/language-reference/operators/bitwise-and-shift-operators" target="_blank">Opérateurs au niveau du bit et opérateurs de décalage (référence C#)</a></html> \\ |
| | </pane> |
| | </tabs> |
| | \\ |
| | ==== Résumé ==== |
| | * Les variables **conservent les données** du programme lors de son exécution. Leur contenu peut changer. Il faut éviter de mettre des espaces et des accents dans les noms de variable. |
| | * Pour affecter une valeur à une variable, on utilise la syntaxe: //nomVariable **=** valeur//. |
| | * Il existe différents types de variables : **entier**, **réel**, **chaîne de caractères**, etc. |
| | * Les variables **locales**, définies avant l'appel d'une fonction, sont accessibles en lecture seule depuis l'appel de la fonction. Une variable locale définie dans une fonction est supprimée après l'exécution de la fonction. |
| | * Les variables **globales** se définissent à l'aide du mot-clé //**globale**// suivi du nom de la variable préalablement créée. Elles peuvent être modifiées dans le corps d'une fonction. |
| | |
| | ---- |
| |